// Copyright 2010-2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "composer/composer.h"

#include <string>
#include <utility>
#include <vector>

#include "base/logging.h"
#include "base/singleton.h"
#include "base/system_util.h"
#include "base/util.h"
#include "composer/internal/typing_model.h"
#include "composer/table.h"
#include "config/character_form_manager.h"
#include "config/config.pb.h"
#include "config/config_handler.h"
#include "session/commands.pb.h"
#include "session/key_parser.h"
#include "testing/base/public/gunit.h"

DECLARE_string(test_tmpdir);

namespace mozc {
namespace composer {

using ::mozc::config::CharacterFormManager;
using ::mozc::config::Config;
using ::mozc::config::ConfigHandler;
using ::mozc::commands::Request;

namespace {
bool InsertKey(const string &key_string, Composer *composer) {
  commands::KeyEvent key;
  if (!KeyParser::ParseKey(key_string, &key)) {
    return false;
  }
  return composer->InsertCharacterKeyEvent(key);
}

bool InsertKeyWithMode(const string &key_string,
                       const commands::CompositionMode mode,
                       Composer *composer) {
  commands::KeyEvent key;
  if (!KeyParser::ParseKey(key_string, &key)) {
    return false;
  }
  key.set_mode(mode);
  return composer->InsertCharacterKeyEvent(key);
}

string GetPreedit(const Composer *composer) {
  string preedit;
  composer->GetStringForPreedit(&preedit);
  return preedit;
}

void ExpectSameComposer(const Composer &lhs, const Composer &rhs) {
  EXPECT_EQ(lhs.GetCursor(), rhs.GetCursor());
  EXPECT_EQ(lhs.is_new_input(), rhs.is_new_input());
  EXPECT_EQ(lhs.GetInputMode(), rhs.GetInputMode());
  EXPECT_EQ(lhs.GetOutputMode(), rhs.GetOutputMode());
  EXPECT_EQ(lhs.GetComebackInputMode(), rhs.GetComebackInputMode());
  EXPECT_EQ(lhs.shifted_sequence_count(), rhs.shifted_sequence_count());
  EXPECT_EQ(lhs.source_text(), rhs.source_text());
  EXPECT_EQ(lhs.max_length(), rhs.max_length());
  EXPECT_EQ(lhs.GetInputFieldType(), rhs.GetInputFieldType());

  {
    string left_text, right_text;
    lhs.GetStringForPreedit(&left_text);
    rhs.GetStringForPreedit(&right_text);
    EXPECT_EQ(left_text, right_text);
  }
  {
    string left_text, right_text;
    lhs.GetStringForSubmission(&left_text);
    rhs.GetStringForSubmission(&right_text);
    EXPECT_EQ(left_text, right_text);
  }
  {
    string left_text, right_text;
    lhs.GetQueryForConversion(&left_text);
    rhs.GetQueryForConversion(&right_text);
    EXPECT_EQ(left_text, right_text);
  }
  {
    string left_text, right_text;
    lhs.GetQueryForPrediction(&left_text);
    rhs.GetQueryForPrediction(&right_text);
    EXPECT_EQ(left_text, right_text);
  }
}

}  // namespace

class ComposerTest : public testing::Test {
 protected:
  ComposerTest() {}

  virtual void SetUp() {
    SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir);
    Config config;
    ConfigHandler::GetDefaultConfig(&config);
    ConfigHandler::SetConfig(config);
    table_.reset(new Table);
    default_request_.reset(new Request);
    composer_.reset(new Composer(table_.get(), default_request_.get()));
    CharacterFormManager::GetCharacterFormManager()->SetDefaultRule();
  }

  virtual void TearDown() {
    CharacterFormManager::GetCharacterFormManager()->SetDefaultRule();
    composer_.reset();
    default_request_.reset();
    table_.reset();

    // just in case, reset config in test_tmpdir
    Config config;
    ConfigHandler::GetDefaultConfig(&config);
    ConfigHandler::SetConfig(config);
  }

  scoped_ptr<Composer> composer_;
  scoped_ptr<Table> table_;
  scoped_ptr<Request> default_request_;

 private:
  DISALLOW_COPY_AND_ASSIGN(ComposerTest);
};


TEST_F(ComposerTest, Reset) {
  composer_->InsertCharacter("mozuku");

  composer_->SetInputMode(transliteration::HALF_ASCII);

  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetOutputMode());
  composer_->SetOutputMode(transliteration::HALF_ASCII);
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetOutputMode());

  composer_->SetInputFieldType(commands::Context::PASSWORD);
  composer_->Reset();

  EXPECT_TRUE(composer_->Empty());
  // The input mode ramains as the previous mode.
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());
  EXPECT_EQ(commands::Context::PASSWORD,
            composer_->GetInputFieldType());
  // The output mode should be reset.
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetOutputMode());
}

TEST_F(ComposerTest, ResetInputMode) {
  composer_->InsertCharacter("mozuku");

  composer_->SetInputMode(transliteration::FULL_KATAKANA);
  composer_->SetTemporaryInputMode(transliteration::HALF_ASCII);
  composer_->ResetInputMode();

  EXPECT_FALSE(composer_->Empty());
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
}

TEST_F(ComposerTest, Empty) {
  composer_->InsertCharacter("mozuku");
  EXPECT_FALSE(composer_->Empty());

  composer_->EditErase();
  EXPECT_TRUE(composer_->Empty());
}

TEST_F(ComposerTest, EnableInsert) {
  composer_->set_max_length(6);

  composer_->InsertCharacter("mozuk");
  EXPECT_EQ(5, composer_->GetLength());

  EXPECT_TRUE(composer_->EnableInsert());
  composer_->InsertCharacter("u");
  EXPECT_EQ(6, composer_->GetLength());

  EXPECT_FALSE(composer_->EnableInsert());
  composer_->InsertCharacter("!");
  EXPECT_EQ(6, composer_->GetLength());

  string result;
  composer_->GetQueryForConversion(&result);
  EXPECT_EQ("mozuku", result);

  composer_->Backspace();
  EXPECT_EQ(5, composer_->GetLength());
  EXPECT_TRUE(composer_->EnableInsert());
}

TEST_F(ComposerTest, BackSpace) {
  composer_->InsertCharacter("abc");

  composer_->Backspace();
  EXPECT_EQ(2, composer_->GetLength());
  EXPECT_EQ(2, composer_->GetCursor());
  string result;
  composer_->GetQueryForConversion(&result);
  EXPECT_EQ("ab", result);

  result.clear();
  composer_->GetQueryForConversion(&result);
  EXPECT_EQ("ab", result);

  composer_->MoveCursorToBeginning();
  EXPECT_EQ(0, composer_->GetCursor());

  composer_->Backspace();
  EXPECT_EQ(2, composer_->GetLength());
  EXPECT_EQ(0, composer_->GetCursor());
  result.clear();
  composer_->GetQueryForConversion(&result);
  EXPECT_EQ("ab", result);

  composer_->Backspace();
  EXPECT_EQ(2, composer_->GetLength());
  EXPECT_EQ(0, composer_->GetCursor());
  result.clear();
  composer_->GetQueryForConversion(&result);
  EXPECT_EQ("ab", result);
}

TEST_F(ComposerTest, OutputMode) {
  // This behaviour is based on Kotoeri

  // "あ"
  table_->AddRule("a", "\xe3\x81\x82", "");
  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");
  // "う"
  table_->AddRule("u", "\xe3\x81\x86", "");

  composer_->SetOutputMode(transliteration::HIRAGANA);

  composer_->InsertCharacter("a");
  composer_->InsertCharacter("i");
  composer_->InsertCharacter("u");

  string output;
  composer_->GetStringForPreedit(&output);
  // "あいう"
  EXPECT_EQ("\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86", output);

  composer_->SetOutputMode(transliteration::FULL_ASCII);
  composer_->GetStringForPreedit(&output);
  // "ａｉｕ"
  EXPECT_EQ("\xEF\xBD\x81\xEF\xBD\x89\xEF\xBD\x95", output);

  composer_->InsertCharacter("a");
  composer_->InsertCharacter("i");
  composer_->InsertCharacter("u");
  composer_->GetStringForPreedit(&output);
  // "ａｉｕあいう"
  EXPECT_EQ("\xEF\xBD\x81\xEF\xBD\x89\xEF\xBD\x95"
            "\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86",
            output);
}

TEST_F(ComposerTest, OutputMode_2) {
  // This behaviour is based on Kotoeri

  // "あ"
  table_->AddRule("a", "\xe3\x81\x82", "");
  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");
  // "う"
  table_->AddRule("u", "\xe3\x81\x86", "");

  composer_->InsertCharacter("a");
  composer_->InsertCharacter("i");
  composer_->InsertCharacter("u");

  string output;
  composer_->GetStringForPreedit(&output);
  // "あいう"
  EXPECT_EQ("\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86", output);

  composer_->MoveCursorLeft();
  composer_->SetOutputMode(transliteration::FULL_ASCII);
  composer_->GetStringForPreedit(&output);
  // "ａｉｕ"
  EXPECT_EQ("\xEF\xBD\x81\xEF\xBD\x89\xEF\xBD\x95", output);

  composer_->InsertCharacter("a");
  composer_->InsertCharacter("i");
  composer_->InsertCharacter("u");
  composer_->GetStringForPreedit(&output);
  // "ａｉｕあいう"
  EXPECT_EQ("\xEF\xBD\x81\xEF\xBD\x89\xEF\xBD\x95"
            "\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86",
            output);
}

TEST_F(ComposerTest, GetTransliterations) {
  // "あ"
  table_->AddRule("a", "\xe3\x81\x82", "");
  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");
  // "う"
  table_->AddRule("u", "\xe3\x81\x86", "");
  // "あ"
  table_->AddRule("A", "\xe3\x81\x82", "");
  // "い"
  table_->AddRule("I", "\xe3\x81\x84", "");
  // "う"
  table_->AddRule("U", "\xe3\x81\x86", "");
  composer_->InsertCharacter("a");

  transliteration::Transliterations transliterations;
  composer_->GetTransliterations(&transliterations);
  EXPECT_EQ(transliteration::NUM_T13N_TYPES, transliterations.size());
  // "あ"
  EXPECT_EQ("\xe3\x81\x82", transliterations[transliteration::HIRAGANA]);
  // "ア"
  EXPECT_EQ("\xe3\x82\xa2", transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("a", transliterations[transliteration::HALF_ASCII]);
  // "ａ"
  EXPECT_EQ("\xef\xbd\x81", transliterations[transliteration::FULL_ASCII]);
  // "ｱ"
  EXPECT_EQ("\xef\xbd\xb1", transliterations[transliteration::HALF_KATAKANA]);

  composer_->Reset();
  ASSERT_TRUE(composer_->Empty());
  transliterations.clear();

  composer_->InsertCharacter("!");
  composer_->GetTransliterations(&transliterations);
  EXPECT_EQ(transliteration::NUM_T13N_TYPES, transliterations.size());
  // NOTE(komatsu): The duplication will be handled by the session layer.
  // "！"
  EXPECT_EQ("\xef\xbc\x81", transliterations[transliteration::HIRAGANA]);
  // "！"
  EXPECT_EQ("\xef\xbc\x81", transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("!", transliterations[transliteration::HALF_ASCII]);
  // "！"
  EXPECT_EQ("\xef\xbc\x81", transliterations[transliteration::FULL_ASCII]);
  EXPECT_EQ("!", transliterations[transliteration::HALF_KATAKANA]);

  composer_->Reset();
  ASSERT_TRUE(composer_->Empty());
  transliterations.clear();

  composer_->InsertCharacter("aIu");
  composer_->GetTransliterations(&transliterations);
  EXPECT_EQ(transliteration::NUM_T13N_TYPES, transliterations.size());
  // "あいう"
  EXPECT_EQ("\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86",
            transliterations[transliteration::HIRAGANA]);
  // "アイウ"
  EXPECT_EQ("\xe3\x82\xa2\xe3\x82\xa4\xe3\x82\xa6",
            transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("aIu", transliterations[transliteration::HALF_ASCII]);
  EXPECT_EQ("AIU", transliterations[transliteration::HALF_ASCII_UPPER]);
  EXPECT_EQ("aiu", transliterations[transliteration::HALF_ASCII_LOWER]);
  EXPECT_EQ("Aiu", transliterations[transliteration::HALF_ASCII_CAPITALIZED]);
  // "ａＩｕ"
  EXPECT_EQ("\xef\xbd\x81\xef\xbc\xa9\xef\xbd\x95",
            transliterations[transliteration::FULL_ASCII]);
  // "ＡＩＵ"
  EXPECT_EQ("\xef\xbc\xa1\xef\xbc\xa9\xef\xbc\xb5",
            transliterations[transliteration::FULL_ASCII_UPPER]);
  // "ａｉｕ"
  EXPECT_EQ("\xef\xbd\x81\xef\xbd\x89\xef\xbd\x95",
            transliterations[transliteration::FULL_ASCII_LOWER]);
  // "Ａｉｕ"
  EXPECT_EQ("\xef\xbc\xa1\xef\xbd\x89\xef\xbd\x95",
            transliterations[transliteration::FULL_ASCII_CAPITALIZED]);
  // "ｱｲｳ"
  EXPECT_EQ("\xef\xbd\xb1\xef\xbd\xb2\xef\xbd\xb3",
            transliterations[transliteration::HALF_KATAKANA]);

  // Transliterations for quote marks.  This is a test against
  // http://b/1581367
  composer_->Reset();
  ASSERT_TRUE(composer_->Empty());
  transliterations.clear();

  composer_->InsertCharacter("'\"`");
  composer_->GetTransliterations(&transliterations);
  // "'" -> \u2019
  // """ -> \u201d
  // "`" -> \uff40
  EXPECT_EQ("'\"`", transliterations[transliteration::HALF_ASCII]);
  // "’”｀"
  EXPECT_EQ("\xe2\x80\x99\xe2\x80\x9d\xef\xbd\x80",
            transliterations[transliteration::FULL_ASCII]);
}

TEST_F(ComposerTest, GetSubTransliterations) {
  // "か"
  table_->AddRule("ka", "\xe3\x81\x8b", "");
  // "ん"
  table_->AddRule("n", "\xe3\x82\x93", "");
  // "な"
  table_->AddRule("na", "\xe3\x81\xaa", "");
  // "だ"
  table_->AddRule("da", "\xe3\x81\xa0", "");

  composer_->InsertCharacter("kanna");

  transliteration::Transliterations transliterations;
  composer_->GetSubTransliterations(0, 2, &transliterations);
  // "かん"
  EXPECT_EQ("\xe3\x81\x8b\xe3\x82\x93",
            transliterations[transliteration::HIRAGANA]);
  // "カン"
  EXPECT_EQ("\xe3\x82\xab\xe3\x83\xb3",
            transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("kan", transliterations[transliteration::HALF_ASCII]);
  // "ｋａｎ"
  EXPECT_EQ("\xef\xbd\x8b\xef\xbd\x81\xef\xbd\x8e",
            transliterations[transliteration::FULL_ASCII]);
  // "ｶﾝ"
  EXPECT_EQ("\xef\xbd\xb6\xef\xbe\x9d",
            transliterations[transliteration::HALF_KATAKANA]);

  transliterations.clear();
  composer_->GetSubTransliterations(1, 1, &transliterations);
  // "ん"
  EXPECT_EQ("\xe3\x82\x93", transliterations[transliteration::HIRAGANA]);
  // "ン"
  EXPECT_EQ("\xe3\x83\xb3", transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("n", transliterations[transliteration::HALF_ASCII]);
  // "ｎ"
  EXPECT_EQ("\xef\xbd\x8e", transliterations[transliteration::FULL_ASCII]);
  // "ﾝ"
  EXPECT_EQ("\xef\xbe\x9d", transliterations[transliteration::HALF_KATAKANA]);

  transliterations.clear();
  composer_->GetSubTransliterations(2, 1, &transliterations);
  // "な"
  EXPECT_EQ("\xe3\x81\xaa", transliterations[transliteration::HIRAGANA]);
  // "ナ"
  EXPECT_EQ("\xe3\x83\x8a", transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("na", transliterations[transliteration::HALF_ASCII]);
  // "ｎａ"
  EXPECT_EQ("\xef\xbd\x8e\xef\xbd\x81",
            transliterations[transliteration::FULL_ASCII]);
  // "ﾅ"
  EXPECT_EQ("\xef\xbe\x85", transliterations[transliteration::HALF_KATAKANA]);

  // Invalid position
  transliterations.clear();
  composer_->GetSubTransliterations(5, 3, &transliterations);
  EXPECT_EQ("", transliterations[transliteration::HIRAGANA]);
  EXPECT_EQ("", transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("", transliterations[transliteration::HALF_ASCII]);
  EXPECT_EQ("", transliterations[transliteration::FULL_ASCII]);
  EXPECT_EQ("", transliterations[transliteration::HALF_KATAKANA]);

  // Invalid size
  transliterations.clear();
  composer_->GetSubTransliterations(0, 999, &transliterations);
  // "かんな"
  EXPECT_EQ("\xe3\x81\x8b\xe3\x82\x93\xe3\x81\xaa",
            transliterations[transliteration::HIRAGANA]);
  // "カンナ"
  EXPECT_EQ("\xe3\x82\xab\xe3\x83\xb3\xe3\x83\x8a",
            transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("kanna", transliterations[transliteration::HALF_ASCII]);
  // "ｋａｎｎａ"
  EXPECT_EQ("\xef\xbd\x8b\xef\xbd\x81\xef\xbd\x8e\xef\xbd\x8e\xef\xbd\x81",
            transliterations[transliteration::FULL_ASCII]);
  // "ｶﾝﾅ"
  EXPECT_EQ("\xef\xbd\xb6\xef\xbe\x9d\xef\xbe\x85",
            transliterations[transliteration::HALF_KATAKANA]);

  // Dakuon case
  transliterations.clear();
  composer_->EditErase();
  composer_->InsertCharacter("dankann");
  composer_->GetSubTransliterations(0, 3, &transliterations);
  // "だんか"
  EXPECT_EQ("\xe3\x81\xa0\xe3\x82\x93\xe3\x81\x8b",
            transliterations[transliteration::HIRAGANA]);
  // "ダンカ"
  EXPECT_EQ("\xe3\x83\x80\xe3\x83\xb3\xe3\x82\xab",
            transliterations[transliteration::FULL_KATAKANA]);
  EXPECT_EQ("danka", transliterations[transliteration::HALF_ASCII]);
  // "ｄａｎｋａ"
  EXPECT_EQ("\xef\xbd\x84\xef\xbd\x81\xef\xbd\x8e\xef\xbd\x8b\xef\xbd\x81",
            transliterations[transliteration::FULL_ASCII]);
  // "ﾀﾞﾝｶ"
  EXPECT_EQ("\xef\xbe\x80\xef\xbe\x9e\xef\xbe\x9d\xef\xbd\xb6",
            transliterations[transliteration::HALF_KATAKANA]);
}

TEST_F(ComposerTest, GetStringFunctions) {
  // "か"
  table_->AddRule("ka", "\xe3\x81\x8b", "");
  // "ん"
  table_->AddRule("n", "\xe3\x82\x93", "");
  // "な"
  table_->AddRule("na", "\xe3\x81\xaa", "");
  // "さ"
  table_->AddRule("sa", "\xe3\x81\x95", "");

  // Query: "!kan"
  composer_->InsertCharacter("!kan");
  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "！かｎ"
  EXPECT_EQ("\xef\xbc\x81\xe3\x81\x8b\xef\xbd\x8e", preedit);

  string submission;
  composer_->GetStringForSubmission(&submission);
  // "！かｎ"
  EXPECT_EQ("\xef\xbc\x81\xe3\x81\x8b\xef\xbd\x8e", submission);

  string conversion;
  composer_->GetQueryForConversion(&conversion);
  // "!かん"
  EXPECT_EQ("\x21\xe3\x81\x8b\xe3\x82\x93", conversion);

  string prediction;
  composer_->GetQueryForPrediction(&prediction);
  // "!か"
  EXPECT_EQ("\x21\xe3\x81\x8b", prediction);

  // Query: "kas"
  composer_->EditErase();
  composer_->InsertCharacter("kas");

  preedit.clear();
  composer_->GetStringForPreedit(&preedit);
  // "かｓ"
  EXPECT_EQ("\xe3\x81\x8b\xef\xbd\x93", preedit);

  submission.clear();
  composer_->GetStringForSubmission(&submission);
  // "かｓ"
  EXPECT_EQ("\xe3\x81\x8b\xef\xbd\x93", submission);

  // Pending chars should remain.  This is a test against
  // http://b/1799399
  conversion.clear();
  composer_->GetQueryForConversion(&conversion);
  // "かs"
  EXPECT_EQ("\xe3\x81\x8b\x73", conversion);

  prediction.clear();
  composer_->GetQueryForPrediction(&prediction);
  // "か"
  EXPECT_EQ("\xe3\x81\x8b", prediction);

  // Query: "s"
  composer_->EditErase();
  composer_->InsertCharacter("s");

  preedit.clear();
  composer_->GetStringForPreedit(&preedit);
  // "ｓ"
  EXPECT_EQ("\xef\xbd\x93", preedit);

  submission.clear();
  composer_->GetStringForSubmission(&submission);
  // "ｓ"
  EXPECT_EQ("\xef\xbd\x93", submission);

  conversion.clear();
  composer_->GetQueryForConversion(&conversion);
  // "s"
  EXPECT_EQ("s", conversion);

  prediction.clear();
  composer_->GetQueryForPrediction(&prediction);
  EXPECT_EQ("s", prediction);

  // Query: "sk"
  composer_->EditErase();
  composer_->InsertCharacter("sk");

  preedit.clear();
  composer_->GetStringForPreedit(&preedit);
  // "ｓｋ"
  EXPECT_EQ("\xef\xbd\x93\xEF\xBD\x8B", preedit);

  submission.clear();
  composer_->GetStringForSubmission(&submission);
  // "ｓｋ"
  EXPECT_EQ("\xef\xbd\x93\xEF\xBD\x8B", submission);

  conversion.clear();
  composer_->GetQueryForConversion(&conversion);
  // "sk"
  EXPECT_EQ("sk", conversion);

  prediction.clear();
  composer_->GetQueryForPrediction(&prediction);
  // "sk"
  EXPECT_EQ("sk", prediction);
}

TEST_F(ComposerTest, GetQueryForPredictionHalfAscii) {
  // Dummy setup of romanji table.
  table_->AddRule("he", "\xe3\x81\xb8", "");  // "へ"
  table_->AddRule("ll", "\xe3\x81\xa3\xef\xbd\x8c", "");  // "っｌ"
  table_->AddRule("lo", "\xe3\x82\x8d", "");  // "ろ"

  // Switch to Half-Latin input mode.
  composer_->SetInputMode(transliteration::HALF_ASCII);

  string prediction;
  {
    const char kInput[] = "hello";
    composer_->InsertCharacter(kInput);
    composer_->GetQueryForPrediction(&prediction);
    EXPECT_EQ(kInput, prediction);
  }
  prediction.clear();
  composer_->EditErase();
  {
    const char kInput[] = "hello!";
    composer_->InsertCharacter(kInput);
    composer_->GetQueryForPrediction(&prediction);
    EXPECT_EQ(kInput, prediction);
  }
}

TEST_F(ComposerTest, GetQueryForPredictionFullAscii) {
  // Dummy setup of romanji table.
  table_->AddRule("he", "\xe3\x81\xb8", "");  // "へ"
  table_->AddRule("ll", "\xe3\x81\xa3\xef\xbd\x8c", "");  // "っｌ"
  table_->AddRule("lo", "\xe3\x82\x8d", "");  // "ろ"

  // Switch to Full-Latin input mode.
  composer_->SetInputMode(transliteration::FULL_ASCII);

  string prediction;
  {
    // "ｈｅｌｌｏ"
    composer_->InsertCharacter(
        "\xef\xbd\x88\xef\xbd\x85\xef\xbd\x8c\xef\xbd\x8c\xef\xbd\x8f");
    composer_->GetQueryForPrediction(&prediction);
    EXPECT_EQ("hello", prediction);
  }
  prediction.clear();
  composer_->EditErase();
  {
    // "ｈｅｌｌｏ！"
    composer_->InsertCharacter(
        "\xef\xbd\x88\xef\xbd\x85\xef\xbd\x8c\xef\xbd\x8c"
        "\xef\xbd\x8f\xef\xbc\x81");
    composer_->GetQueryForPrediction(&prediction);
    EXPECT_EQ("hello!", prediction);
  }
}

TEST_F(ComposerTest, GetQueriesForPredictionRoman) {
  // "う"
  table_->AddRule("u", "\xe3\x81\x86", "");
  // "っ"
  table_->AddRule("ss", "\xe3\x81\xa3", "s");
  // "さ"
  table_->AddRule("sa", "\xe3\x81\x95", "");
  // "し"
  table_->AddRule("si", "\xe3\x81\x97", "");
  // "す"
  table_->AddRule("su", "\xe3\x81\x99", "");
  // "せ"
  table_->AddRule("se", "\xe3\x81\x9b", "");
  // "そ"
  table_->AddRule("so", "\xe3\x81\x9d", "");

  {
    string base, preedit;
    set<string> expanded;
    composer_->EditErase();
    composer_->InsertCharacter("us");
    composer_->GetQueriesForPrediction(&base, &expanded);
    composer_->GetStringForPreedit(&preedit);
    // "う"
    EXPECT_EQ("\xe3\x81\x86", base);
    EXPECT_EQ(7, expanded.size());
    // We can't use EXPECT_NE for iterator
    EXPECT_TRUE(expanded.end() != expanded.find("s"));
    // "っ"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\xa3"));
    // "さ"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\x95"));
    // "し"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\x97"));
    // "す"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\x99"));
    // "せ"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\x9b"));
    // "そ"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\x9d"));
  }
}

TEST_F(ComposerTest, GetQueriesForPredictionMobile) {
  // "い"
  table_->AddRule("_", "", "\xe3\x81\x84");
  // "い*", "ぃ"
  table_->AddRule("\xe3\x81\x84\x2a", "", "\xe3\x81\x83");
  // "ぃ*", "い"
  table_->AddRule("\xe3\x81\x83\x2a", "", "\xe3\x81\x84");
  // "と"
  table_->AddRule("$", "", "\xe3\x81\xa8");
  // "と*", "ど"
  table_->AddRule("\xe3\x81\xa8\x2a", "", "\xe3\x81\xa9");
  // "ど*", "と"
  table_->AddRule("\xe3\x81\xa9\x2a", "", "\xe3\x81\xa8");

  {
    string base, preedit;
    set<string> expanded;
    composer_->EditErase();
    composer_->InsertCharacter("_$");
    composer_->GetQueriesForPrediction(&base, &expanded);
    composer_->GetStringForPreedit(&preedit);
    // "い"
    EXPECT_EQ("\xe3\x81\x84", base);
    EXPECT_EQ(2, expanded.size());
    // "と"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\xa8"));
    // "ど"
    EXPECT_TRUE(expanded.end() != expanded.find("\xe3\x81\xa9"));
  }
}

TEST_F(ComposerTest, GetStringFunctions_ForN) {
  table_->AddRule("a", "[A]", "");
  table_->AddRule("n", "[N]", "");
  table_->AddRule("nn", "[N]", "");
  table_->AddRule("na", "[NA]", "");
  table_->AddRule("nya", "[NYA]", "");
  table_->AddRule("ya", "[YA]", "");
  table_->AddRule("ka", "[KA]", "");

  composer_->InsertCharacter("nynyan");
  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "ｎｙ［ＮＹＡ］ｎ"
  EXPECT_EQ("\xEF\xBD\x8E\xEF\xBD\x99\xEF\xBC\xBB\xEF\xBC\xAE\xEF\xBC\xB9"
            "\xEF\xBC\xA1\xEF\xBC\xBD\xEF\xBD\x8E", preedit);

  string submission;
  composer_->GetStringForSubmission(&submission);
  // "ｎｙ［ＮＹＡ］ｎ"
  EXPECT_EQ("\xEF\xBD\x8E\xEF\xBD\x99\xEF\xBC\xBB\xEF\xBC\xAE\xEF\xBC\xB9"
            "\xEF\xBC\xA1\xEF\xBC\xBD\xEF\xBD\x8E", submission);

  string conversion;
  composer_->GetQueryForConversion(&conversion);
  EXPECT_EQ("ny[NYA][N]", conversion);

  string prediction;
  composer_->GetQueryForPrediction(&prediction);
  EXPECT_EQ("ny[NYA]", prediction);

  composer_->InsertCharacter("ka");
  string conversion2;
  composer_->GetQueryForConversion(&conversion2);
  EXPECT_EQ("ny[NYA][N][KA]", conversion2);

  string prediction2;
  composer_->GetQueryForPrediction(&prediction2);
  EXPECT_EQ("ny[NYA][N][KA]", prediction2);
}

TEST_F(ComposerTest, GetStringFunctions_InputFieldType) {
  const struct TestData {
    const commands::Context::InputFieldType field_type_;
    const bool ascii_expected_;
  } test_data_list[] = {
      {commands::Context::NORMAL, false},
      {commands::Context::NUMBER, true},
      {commands::Context::PASSWORD, true},
      {commands::Context::TEL, true},
  };

  composer_->SetInputMode(transliteration::HIRAGANA);
  for (size_t test_data_index = 0;
       test_data_index < arraysize(test_data_list);
       ++test_data_index) {
    const TestData &test_data = test_data_list[test_data_index];
    composer_->SetInputFieldType(test_data.field_type_);
    string key, converted;
    for (char c = 0x20; c <= 0x7E; ++c) {
      key.assign(1, c);
      composer_->EditErase();
      composer_->InsertCharacter(key);
      if (test_data.ascii_expected_) {
        composer_->GetStringForPreedit(&converted);
        EXPECT_EQ(key, converted);
        composer_->GetStringForSubmission(&converted);
        EXPECT_EQ(key, converted);
      } else {
        // Expected result is FULL_WIDTH form.
        // Typically the result is a full-width form of the key,
        // but some characters are not.
        // So here we checks only the character form.
        composer_->GetStringForPreedit(&converted);
        EXPECT_EQ(Util::FULL_WIDTH, Util::GetFormType(converted));
        composer_->GetStringForSubmission(&converted);
        EXPECT_EQ(Util::FULL_WIDTH, Util::GetFormType(converted));
      }
    }
  }
}

TEST_F(ComposerTest, InsertCommandCharacter) {
  composer_->SetInputMode(transliteration::HALF_ASCII);
  composer_->InsertCommandCharacter(Composer::REWIND);
  EXPECT_EQ("\x0F<\x0E", GetPreedit(composer_.get()));
}

TEST_F(ComposerTest, InsertCharacterKeyEvent) {
  commands::KeyEvent key;
  // "あ"
  table_->AddRule("a", "\xe3\x81\x82", "");

  key.set_key_code('a');
  composer_->InsertCharacterKeyEvent(key);

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "あ"
  EXPECT_EQ("\xe3\x81\x82", preedit);

  // Half width "A" will be inserted.
  key.set_key_code('A');
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あA"
  EXPECT_EQ("\xe3\x81\x82\x41", preedit);

  // Half width "a" will be inserted.
  key.set_key_code('a');
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あAa"
  EXPECT_EQ("\xe3\x81\x82\x41\x61", preedit);

  // Reset() should revert the previous input mode (Hiragana).
  composer_->Reset();

  key.set_key_code('a');
  composer_->InsertCharacterKeyEvent(key);
  composer_->GetStringForPreedit(&preedit);
  // "あ"
  EXPECT_EQ("\xE3\x81\x82", preedit);

  // Typing "A" temporarily switch the input mode.  The input mode
  // should be reverted back after reset.
  composer_->SetInputMode(transliteration::FULL_KATAKANA);
  key.set_key_code('a');
  composer_->InsertCharacterKeyEvent(key);
  composer_->GetStringForPreedit(&preedit);
  // "あア"
  EXPECT_EQ("\xE3\x81\x82\xE3\x82\xA2", preedit);

  key.set_key_code('A');
  composer_->InsertCharacterKeyEvent(key);
  composer_->GetStringForPreedit(&preedit);
  // "あアA"
  EXPECT_EQ("\xE3\x81\x82\xE3\x82\xA2\x41", preedit);

  // Reset() should revert the previous input mode (Katakana).
  composer_->Reset();

  key.set_key_code('a');
  composer_->InsertCharacterKeyEvent(key);
  composer_->GetStringForPreedit(&preedit);
  // "ア"
  EXPECT_EQ("\xE3\x82\xA2", preedit);
}

namespace {
// "山"
const char kYama[] = "\xE5\xB1\xB1";
// "川"
const char kKawa[] = "\xE5\xB7\x9D";
// "空"
const char kSora[] = "\xE7\xA9\xBA";
}  // namespace

TEST_F(ComposerTest, InsertCharacterKeyEventWithUcs4KeyCode) {
  commands::KeyEvent key;

  // Input "山" as key_code.
  key.set_key_code(0x5C71);  // U+5C71 = "山"
  composer_->InsertCharacterKeyEvent(key);

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  EXPECT_EQ(kYama, preedit);

  // Input "山" as key_code which is converted to "川".
  table_->AddRule(kYama, kKawa, "");
  composer_->Reset();
  composer_->InsertCharacterKeyEvent(key);
  composer_->GetStringForPreedit(&preedit);
  EXPECT_EQ(kKawa, preedit);

  // Input ("山", "空") as (key_code, key_string) which is treated as "空".
  key.set_key_string(kSora);
  composer_->Reset();
  composer_->InsertCharacterKeyEvent(key);
  composer_->GetStringForPreedit(&preedit);
  EXPECT_EQ(kSora, preedit);
}

TEST_F(ComposerTest, InsertCharacterKeyEventWithoutKeyCode) {
  commands::KeyEvent key;

  // Input "山" as key_string.  key_code is empty.
  key.set_key_string(kYama);
  composer_->InsertCharacterKeyEvent(key);
  EXPECT_FALSE(key.has_key_code());

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  EXPECT_EQ(kYama, preedit);

  transliteration::Transliterations transliterations;
  composer_->GetTransliterations(&transliterations);
  EXPECT_EQ(kYama, transliterations[transliteration::HIRAGANA]);
  EXPECT_EQ(kYama, transliterations[transliteration::HALF_ASCII]);
}

TEST_F(ComposerTest, InsertCharacterKeyEventWithAsIs) {
  commands::KeyEvent key;
  // "あ"
  table_->AddRule("a", "\xe3\x81\x82", "");
  // "ー"
  table_->AddRule("-", "\xE3\x83\xBC", "");

  key.set_key_code('a');
  composer_->InsertCharacterKeyEvent(key);

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "あ"
  EXPECT_EQ("\xe3\x81\x82", preedit);

  // Full width "０" will be inserted.
  key.set_key_code('0');
  key.set_key_string("0");
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あ０"
  EXPECT_EQ("\xE3\x81\x82\xEF\xBC\x90", preedit);

  // Half width "0" will be inserted.
  key.set_key_code('0');
  key.set_key_string("0");
  key.set_input_style(commands::KeyEvent::AS_IS);
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あ０0"
  EXPECT_EQ("\xE3\x81\x82\xEF\xBC\x90\x30", preedit);

  // Full width "0" will be inserted.
  key.set_key_code('0');
  key.set_key_string("0");
  key.set_input_style(commands::KeyEvent::FOLLOW_MODE);
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あ０0０"
  EXPECT_EQ("\xE3\x81\x82\xEF\xBC\x90\x30\xEF\xBC\x90", preedit);

  // Half width "-" will be inserted.
  key.set_key_code('-');
  key.set_key_string("-");
  key.set_input_style(commands::KeyEvent::AS_IS);
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あ０0０-"
  EXPECT_EQ("\xE3\x81\x82\xEF\xBC\x90\x30\xEF\xBC\x90\x2D", preedit);

  // Full width "−" will be inserted.
  key.set_key_code('-');
  // "−"
  key.set_key_string("\xE2\x88\x92");
  key.set_input_style(commands::KeyEvent::FOLLOW_MODE);
  composer_->InsertCharacterKeyEvent(key);

  composer_->GetStringForPreedit(&preedit);
  // "あ０0０-−"
  EXPECT_EQ("\xE3\x81\x82\xEF\xBC\x90\x30\xEF\xBC\x90\x2D\xE2\x88\x92",
            preedit);
}

TEST_F(ComposerTest, InsertCharacterKeyEventWithInputMode) {
  // "あ"
  table_->AddRule("a", "\xE3\x81\x82", "");
  // "い"
  table_->AddRule("i", "\xE3\x81\x84", "");
  // "う"
  table_->AddRule("u", "\xE3\x81\x86", "");

  {
    // "a" → "あ" (Hiragana)
    EXPECT_TRUE(InsertKeyWithMode("a", commands::HIRAGANA, composer_.get()));
    // "あ"
    EXPECT_EQ("\xE3\x81\x82", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

    // "aI" → "あI" (Alphanumeric)
    EXPECT_TRUE(InsertKeyWithMode("I", commands::HIRAGANA, composer_.get()));
    // "あI"
    EXPECT_EQ("\xE3\x81\x82\x49", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    // "u" → "あIu" (Alphanumeric)
    EXPECT_TRUE(InsertKeyWithMode("u", commands::HALF_ASCII, composer_.get()));
    // "あIu"
    EXPECT_EQ("\xE3\x81\x82\x49\x75", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    // [shift] → "あIu" (Hiragana)
    EXPECT_TRUE(InsertKeyWithMode("Shift", commands::HALF_ASCII,
                                  composer_.get()));
    // "あIu"
    EXPECT_EQ("\xE3\x81\x82\x49\x75", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

    // "u" → "あIuう" (Hiragana)
    EXPECT_TRUE(InsertKeyWithMode("u", commands::HIRAGANA, composer_.get()));
    // "あIuう"
    EXPECT_EQ("\xE3\x81\x82\x49\x75\xE3\x81\x86", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }

  composer_.reset(new Composer(table_.get(), default_request_.get()));

  {
    // "a" → "あ" (Hiragana)
    EXPECT_TRUE(InsertKeyWithMode("a", commands::HIRAGANA, composer_.get()));
    // "あ"
    EXPECT_EQ("\xE3\x81\x82", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

    // "i" (Katakana) → "あイ" (Katakana)
    EXPECT_TRUE(InsertKeyWithMode("i", commands::FULL_KATAKANA,
                                  composer_.get()));
    // "あイ"
    EXPECT_EQ("\xE3\x81\x82\xE3\x82\xA4", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

    // SetInputMode(Alphanumeric) → "あイ" (Alphanumeric)
    composer_->SetInputMode(transliteration::HALF_ASCII);
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    // [shift] → "あイ" (Alphanumeric) - Nothing happens.
    EXPECT_TRUE(InsertKeyWithMode("Shift", commands::HALF_ASCII,
                                  composer_.get()));
    // "あイ"
    EXPECT_EQ("\xE3\x81\x82\xE3\x82\xA4", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    // "U" → "あイ" (Alphanumeric)
    EXPECT_TRUE(InsertKeyWithMode("U", commands::HALF_ASCII,
                                  composer_.get()));
    // "あイU"
    EXPECT_EQ("\xE3\x81\x82\xE3\x82\xA4\x55", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    // [shift] → "あイU" (Alphanumeric) - Nothing happens.
    EXPECT_TRUE(InsertKeyWithMode("Shift", commands::HALF_ASCII,
                                  composer_.get()));
    // "あイU"
    EXPECT_EQ("\xE3\x81\x82\xE3\x82\xA4\x55", GetPreedit(composer_.get()));
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());
  }
}

TEST_F(ComposerTest, ApplyTemporaryInputMode) {
  const bool kCapsLocked = true;
  const bool kCapsUnlocked = false;

  // "あ"
  table_->AddRule("a", "\xE3\x81\x82", "");
  composer_->SetInputMode(transliteration::HIRAGANA);

  // Since handlings of continuous shifted input differ,
  // test cases differ between ASCII_INPUT_MODE and KATAKANA_INPUT_MODE

  {  // ASCII_INPUT_MODE (w/o CapsLock)
    Config config;
    ConfigHandler::GetConfig(&config);
    config.set_shift_key_mode_switch(Config::ASCII_INPUT_MODE);
    ConfigHandler::SetConfig(config);

    // pair<input, use_temporary_input_mode>
    pair<string, bool> kTestDataAscii[] = {
      make_pair("a", false),
      make_pair("A", true),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("a", false),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("a", false),
      make_pair("A", true),
      make_pair(".", true),
      make_pair("a", true),
      make_pair("A", true),
      make_pair("A", true),
      make_pair(".", true),
      make_pair("a", true),
      // "あ"
      make_pair("\xE3\x81\x82", false),
      make_pair("a", false),
    };

    for (int i = 0; i < arraysize(kTestDataAscii); ++i) {
      composer_->ApplyTemporaryInputMode(kTestDataAscii[i].first,
                                         kCapsUnlocked);

      const transliteration::TransliterationType expected =
          kTestDataAscii[i].second
          ? transliteration::HALF_ASCII
          : transliteration::HIRAGANA;

      EXPECT_EQ(expected, composer_->GetInputMode()) << "index=" << i;
      EXPECT_EQ(transliteration::HIRAGANA, composer_->GetComebackInputMode())
          << "index=" << i;
    }
  }

  {  // ASCII_INPUT_MODE (w/ CapsLock)
    Config config;
    ConfigHandler::GetConfig(&config);
    config.set_shift_key_mode_switch(Config::ASCII_INPUT_MODE);
    ConfigHandler::SetConfig(config);

    // pair<input, use_temporary_input_mode>
    pair<string, bool> kTestDataAscii[] = {
      make_pair("A", false),
      make_pair("a", true),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("A", false),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("A", false),
      make_pair("a", true),
      make_pair(".", true),
      make_pair("A", true),
      make_pair("a", true),
      make_pair("a", true),
      make_pair(".", true),
      make_pair("A", true),
      // "あ"
      make_pair("\xE3\x81\x82", false),
      make_pair("A", false),
    };

    for (int i = 0; i < arraysize(kTestDataAscii); ++i) {
      composer_->ApplyTemporaryInputMode(kTestDataAscii[i].first,
                                         kCapsLocked);

      const transliteration::TransliterationType expected =
          kTestDataAscii[i].second
          ? transliteration::HALF_ASCII
          : transliteration::HIRAGANA;

      EXPECT_EQ(expected, composer_->GetInputMode()) << "index=" << i;
      EXPECT_EQ(transliteration::HIRAGANA, composer_->GetComebackInputMode())
          << "index=" << i;
    }
  }

  {  // KATAKANA_INPUT_MODE (w/o CapsLock)
    Config config;
    ConfigHandler::GetConfig(&config);
    config.set_shift_key_mode_switch(Config::KATAKANA_INPUT_MODE);
    ConfigHandler::SetConfig(config);

    // pair<input, use_temporary_input_mode>
    pair<string, bool> kTestDataKatakana[] = {
      make_pair("a", false),
      make_pair("A", true),
      make_pair("a", false),
      make_pair("a", false),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("a", false),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("A", true),
      make_pair("a", false),
      make_pair("A", true),
      make_pair(".", true),
      make_pair("a", false),
      make_pair("A", true),
      make_pair("A", true),
      make_pair(".", true),
      make_pair("a", false),
      // "あ"
      make_pair("\xE3\x81\x82", false),
      make_pair("a", false),
    };

    for (int i = 0; i < arraysize(kTestDataKatakana); ++i) {
      composer_->ApplyTemporaryInputMode(kTestDataKatakana[i].first,
                                         kCapsUnlocked);

      const transliteration::TransliterationType expected =
          kTestDataKatakana[i].second
          ? transliteration::FULL_KATAKANA
          : transliteration::HIRAGANA;

      EXPECT_EQ(expected, composer_->GetInputMode()) << "index=" << i;
      EXPECT_EQ(transliteration::HIRAGANA, composer_->GetComebackInputMode())
          << "index=" << i;
    }
  }

  {  // KATAKANA_INPUT_MODE (w/ CapsLock)
    Config config;
    ConfigHandler::GetConfig(&config);
    config.set_shift_key_mode_switch(Config::KATAKANA_INPUT_MODE);
    ConfigHandler::SetConfig(config);

    // pair<input, use_temporary_input_mode>
    pair<string, bool> kTestDataKatakana[] = {
      make_pair("A", false),
      make_pair("a", true),
      make_pair("A", false),
      make_pair("A", false),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("A", false),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("a", true),
      make_pair("A", false),
      make_pair("a", true),
      make_pair(".", true),
      make_pair("A", false),
      make_pair("a", true),
      make_pair("a", true),
      make_pair(".", true),
      make_pair("A", false),
      // "あ"
      make_pair("\xE3\x81\x82", false),
      make_pair("A", false),
    };

    for (int i = 0; i < arraysize(kTestDataKatakana); ++i) {
      composer_->ApplyTemporaryInputMode(kTestDataKatakana[i].first,
                                         kCapsLocked);

      const transliteration::TransliterationType expected =
          kTestDataKatakana[i].second
          ? transliteration::FULL_KATAKANA
          : transliteration::HIRAGANA;

      EXPECT_EQ(expected, composer_->GetInputMode()) << "index=" << i;
      EXPECT_EQ(transliteration::HIRAGANA, composer_->GetComebackInputMode())
          << "index=" << i;
    }
  }
}

TEST_F(ComposerTest, CopyFrom) {
  // "あ"
  table_->AddRule("a", "\xE3\x81\x82", "");
  // "ん"
  table_->AddRule("n", "\xE3\x82\x93", "");
  // "な"
  table_->AddRule("na", "\xE3\x81\xAA", "");

  {
    SCOPED_TRACE("Precomposition");

    string src_composition;
    composer_->GetStringForSubmission(&src_composition);
    EXPECT_EQ("", src_composition);

    Composer dest(NULL, default_request_.get());
    dest.CopyFrom(*composer_);

    ExpectSameComposer(*composer_, dest);
  }

  {
    SCOPED_TRACE("Composition");

    composer_->InsertCharacter("a");
    composer_->InsertCharacter("n");
    string src_composition;
    composer_->GetStringForSubmission(&src_composition);
    // "あｎ"
    EXPECT_EQ("\xE3\x81\x82\xEF\xBD\x8E", src_composition);

    Composer dest(NULL, default_request_.get());
    dest.CopyFrom(*composer_);

    ExpectSameComposer(*composer_, dest);
  }

  {
    SCOPED_TRACE("Conversion");

    string src_composition;
    composer_->GetQueryForConversion(&src_composition);
    // "あん"
    EXPECT_EQ("\xE3\x81\x82\xE3\x82\x93", src_composition);

    Composer dest(NULL, default_request_.get());
    dest.CopyFrom(*composer_);

    ExpectSameComposer(*composer_, dest);
  }

  {
    SCOPED_TRACE("Composition with temporary input mode");

    composer_->Reset();
    InsertKey("A", composer_.get());
    InsertKey("a", composer_.get());
    InsertKey("A", composer_.get());
    InsertKey("A", composer_.get());
    InsertKey("a", composer_.get());
    string src_composition;
    composer_->GetStringForSubmission(&src_composition);
    // "AaAAあ"
    EXPECT_EQ("AaAA\xE3\x81\x82", src_composition);

    Composer dest(NULL, default_request_.get());
    dest.CopyFrom(*composer_);

    ExpectSameComposer(*composer_, dest);
  }

  {
    SCOPED_TRACE("Composition with password mode");

    composer_->Reset();
    composer_->SetInputFieldType(commands::Context::PASSWORD);
    composer_->SetInputMode(transliteration::HALF_ASCII);
    composer_->SetOutputMode(transliteration::HALF_ASCII);
    composer_->InsertCharacter("M");
    string src_composition;
    composer_->GetStringForSubmission(&src_composition);
    EXPECT_EQ("M", src_composition);

    Composer dest(NULL, default_request_.get());
    dest.CopyFrom(*composer_);

    ExpectSameComposer(*composer_, dest);
  }
}

TEST_F(ComposerTest, ShiftKeyOperation) {
  commands::KeyEvent key;
  // "あ"
  table_->AddRule("a", "\xe3\x81\x82", "");

  {  // Basic feature.
    composer_->Reset();
    InsertKey("a", composer_.get());  // "あ"
    InsertKey("A", composer_.get());  // "あA"
    InsertKey("a", composer_.get());  // "あAa"
    // Shift reverts the input mode to Hiragana.
    InsertKey("Shift", composer_.get());
    InsertKey("a", composer_.get());  // "あAaあ"
    // Shift does nothing because the input mode has already been reverted.
    InsertKey("Shift", composer_.get());
    InsertKey("a", composer_.get());  // "あAaああ"

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    // "あAaああ"
    EXPECT_EQ("\xE3\x81\x82\x41\x61\xE3\x81\x82\xE3\x81\x82", preedit);
  }

  {  // Revert back to the previous input mode.
    composer_->SetInputMode(transliteration::FULL_KATAKANA);
    composer_->Reset();
    InsertKey("a", composer_.get());  // "ア"
    InsertKey("A", composer_.get());  // "アA"
    InsertKey("a", composer_.get());  // "アAa"
    // Shift reverts the input mode to Hiragana.
    InsertKey("Shift", composer_.get());
    InsertKey("a", composer_.get());  // "アAaア"
    // Shift does nothing because the input mode has already been reverted.
    InsertKey("Shift", composer_.get());
    InsertKey("a", composer_.get());  // "アAaアア"

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    // "アAaアア"
    EXPECT_EQ("\xE3\x82\xA2\x41\x61\xE3\x82\xA2\xE3\x82\xA2", preedit);
    EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
  }

  {  // Multiple shifted characters
    composer_->SetInputMode(transliteration::HIRAGANA);
    composer_->Reset();
    // Sequential shfited keys change the behavior of the next
    // non-shifted key.  "AAaa" Should become "AAああ", "Aaa" should
    // become "Aaa".
    InsertKey("A", composer_.get());  // "A"
    InsertKey("A", composer_.get());  // "AA"
    InsertKey("a", composer_.get());  // "AAあ"
    InsertKey("A", composer_.get());  // "AAあA"
    InsertKey("a", composer_.get());  // "AAあAa"

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    // "AAあAa"
    EXPECT_EQ("\x41\x41\xE3\x81\x82\x41\x61", preedit);
  }

  {  // Multiple shifted characters #2
    composer_->SetInputMode(transliteration::HIRAGANA);
    composer_->Reset();
    InsertKey("D", composer_.get());  // "D"
    InsertKey("&", composer_.get());  // "D&"
    InsertKey("D", composer_.get());  // "D&D"
    InsertKey("2", composer_.get());  // "D&D2"
    InsertKey("a", composer_.get());  // "D&D2a"

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    // "D&D2a"
    EXPECT_EQ("\x44\x26\x44\x32\x61", preedit);
  }

  {  // Full-witdh alphanumeric
    composer_->SetInputMode(transliteration::FULL_ASCII);
    composer_->Reset();
    InsertKey("A", composer_.get());  // "Ａ"
    InsertKey("a", composer_.get());  // "Ａａ"

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    // "Ａａ"
    EXPECT_EQ("\xEF\xBC\xA1\xEF\xBD\x81", preedit);
  }

  {  // Half-witdh alphanumeric
    composer_->SetInputMode(transliteration::HALF_ASCII);
    composer_->Reset();
    InsertKey("A", composer_.get());  // "A"
    InsertKey("a", composer_.get());  // "Aa"

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    EXPECT_EQ("Aa", preedit);
  }
}

TEST_F(ComposerTest, ShiftKeyOperationForKatakana) {
  Config config;
  ConfigHandler::GetConfig(&config);
  config.set_shift_key_mode_switch(Config::KATAKANA_INPUT_MODE);
  ConfigHandler::SetConfig(config);
  table_->InitializeWithRequestAndConfig(*default_request_, config);
  composer_->Reset();
  composer_->SetInputMode(transliteration::HIRAGANA);
  InsertKey("K", composer_.get());
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
  InsertKey("A", composer_.get());
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
  InsertKey("T", composer_.get());
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
  InsertKey("a", composer_.get());
  // See the below comment.
  // EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  InsertKey("k", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  InsertKey("A", composer_.get());
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
  InsertKey("n", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  InsertKey("a", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // NOTE(komatsu): "KATakAna" is converted to "カＴあｋアな" rather
  // than "カタカな".  This is a different behavior from Kotoeri due
  // to avoid complecated implementation.  Unless this is a problem
  // for users, this difference probably remains.
  //
  // "カタカな"
  // EXPECT_EQ("\xE3\x82\xAB\xE3\x82\xBF\xE3\x82\xAB\xE3\x81\xAA", preedit);

  // "カＴあｋアな"
  EXPECT_EQ("\xE3\x82\xAB\xEF\xBC\xB4\xE3\x81\x82"
            "\xEF\xBD\x8B\xE3\x82\xA2\xE3\x81\xAA",
            preedit);

  config.set_shift_key_mode_switch(Config::ASCII_INPUT_MODE);
  ConfigHandler::SetConfig(config);
}

TEST_F(ComposerTest, AutoIMETurnOffEnabled) {
  Config config;
  ConfigHandler::GetConfig(&config);
  config.set_preedit_method(Config::ROMAN);
  config.set_use_auto_ime_turn_off(true);
  ConfigHandler::SetConfig(config);

  table_->InitializeWithRequestAndConfig(*default_request_, config);

  commands::KeyEvent key;

  {  // http
    InsertKey("h", composer_.get());
    InsertKey("t", composer_.get());
    InsertKey("t", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    InsertKey("p", composer_.get());

    string preedit;
    composer_->GetStringForPreedit(&preedit);
    EXPECT_EQ("http", preedit);
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    composer_->Reset();
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }

  composer_.reset(new Composer(table_.get(), default_request_.get()));

  {  // google
    InsertKey("g", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("g", composer_.get());
    InsertKey("l", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    InsertKey("e", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    EXPECT_EQ("google", GetPreedit(composer_.get()));

    InsertKey("a", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    // "googleあ"
    EXPECT_EQ("google\xE3\x81\x82", GetPreedit(composer_.get()));

    composer_->Reset();
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }

  {  // google in full-width alphanumeric mode.
    composer_->SetInputMode(transliteration::FULL_ASCII);
    InsertKey("g", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("g", composer_.get());
    InsertKey("l", composer_.get());
    EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());
    InsertKey("e", composer_.get());
    EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

    // "ｇｏｏｇｌｅ"
    EXPECT_EQ("\xEF\xBD\x87\xEF\xBD\x8F\xEF\xBD\x8F"
              "\xEF\xBD\x87\xEF\xBD\x8C\xEF\xBD\x85",
              GetPreedit(composer_.get()));

    InsertKey("a", composer_.get());
    EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());
    // "ｇｏｏｇｌｅａ"
    EXPECT_EQ("\xEF\xBD\x87\xEF\xBD\x8F\xEF\xBD\x8F"
              "\xEF\xBD\x87\xEF\xBD\x8C\xEF\xBD\x85\xEF\xBD\x81",
              GetPreedit(composer_.get()));

    composer_->Reset();
    EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());
    // Reset to Hiragana mode
    composer_->SetInputMode(transliteration::HIRAGANA);
  }

  {  // Google
    InsertKey("G", composer_.get());
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());
    InsertKey("o", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("g", composer_.get());
    InsertKey("l", composer_.get());
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());
    InsertKey("e", composer_.get());
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());
    EXPECT_EQ("Google", GetPreedit(composer_.get()));

    InsertKey("a", composer_.get());
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());
    EXPECT_EQ("Googlea", GetPreedit(composer_.get()));

    composer_->Reset();
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }

  config.set_shift_key_mode_switch(Config::OFF);
  ConfigHandler::SetConfig(config);
  composer_.reset(new Composer(table_.get(), default_request_.get()));

  {  // Google
    InsertKey("G", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("o", composer_.get());
    InsertKey("g", composer_.get());
    InsertKey("l", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    InsertKey("e", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    EXPECT_EQ("Google", GetPreedit(composer_.get()));

    InsertKey("a", composer_.get());
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
    // "Googleあ"
    EXPECT_EQ("Google\xE3\x81\x82", GetPreedit(composer_.get()));

    composer_->Reset();
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }
}

TEST_F(ComposerTest, AutoIMETurnOffDisabled) {
  Config config;
  ConfigHandler::GetConfig(&config);

  config.set_preedit_method(Config::ROMAN);
  config.set_use_auto_ime_turn_off(false);
  ConfigHandler::SetConfig(config);

  table_->InitializeWithRequestAndConfig(*default_request_, config);

  commands::KeyEvent key;

  // Roman
  key.set_key_code('h');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('t');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('t');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('p');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code(':');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('/');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('/');
  composer_->InsertCharacterKeyEvent(key);

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "ｈっｔｐ：・・"
  EXPECT_EQ("\xEF\xBD\x88\xE3\x81\xA3\xEF\xBD\x94"
            "\xEF\xBD\x90\xEF\xBC\x9A\xE3\x83\xBB\xE3\x83\xBB", preedit);
}

TEST_F(ComposerTest, AutoIMETurnOffKana) {
  Config config;
  ConfigHandler::GetConfig(&config);

  config.set_preedit_method(Config::KANA);
  config.set_use_auto_ime_turn_off(true);
  ConfigHandler::SetConfig(config);

  table_->InitializeWithRequestAndConfig(*default_request_, config);

  commands::KeyEvent key;

  // Kana
  key.set_key_code('h');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('t');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('t');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('p');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code(':');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('/');
  composer_->InsertCharacterKeyEvent(key);

  key.set_key_code('/');
  composer_->InsertCharacterKeyEvent(key);

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "ｈっｔｐ：・・"
  EXPECT_EQ("\xEF\xBD\x88\xE3\x81\xA3\xEF\xBD\x94\xEF\xBD\x90\xEF\xBC\x9A"
            "\xE3\x83\xBB\xE3\x83\xBB", preedit);
}

TEST_F(ComposerTest, KanaPrediction) {
  // "か゛", "か"
  //  table_->AddRule("\xE3\x81\x8B", "\xE3\x81\x8B", "");
  // "か゛", "が"
  //  table_->AddRule("\xE3\x81\x8B\xE3\x82\x9B", "\xE3\x81\x8C", "");
  // "ー", "ー"
  //  table_->AddRule("\xE3\x83\xBC", "\xE3\x83\xBC", "");

  // "か"
  composer_->InsertCharacterKeyAndPreedit("t", "\xE3\x81\x8B");
  {
    string preedit;
    composer_->GetQueryForPrediction(&preedit);
    // "か"
    EXPECT_EQ("\xE3\x81\x8B", preedit);
  }
  // "ー"
  composer_->InsertCharacterKeyAndPreedit("\\", "\xE3\x83\xBC");
  {
    string preedit;
    composer_->GetQueryForPrediction(&preedit);
    // "かー"
    EXPECT_EQ("\xE3\x81\x8B\xE3\x83\xBC", preedit);
  }
  // "、"
  composer_->InsertCharacterKeyAndPreedit(",", "\xE3\x80\x81");
  {
    string preedit;
    composer_->GetQueryForPrediction(&preedit);
    // "かー、"
    EXPECT_EQ("\xE3\x81\x8B\xE3\x83\xBC\xE3\x80\x81", preedit);
  }
}

TEST_F(ComposerTest, KanaTransliteration) {
  // "く゛", "ぐ"
  table_->AddRule("\xE3\x81\x8F\xE3\x82\x9B", "\xE3\x81\x90", "");
  // "く"
  composer_->InsertCharacterKeyAndPreedit("h", "\xE3\x81\x8F");
  // "い"
  composer_->InsertCharacterKeyAndPreedit("e", "\xE3\x81\x84");
  // "り"
  composer_->InsertCharacterKeyAndPreedit("l", "\xE3\x82\x8A");
  // "り"
  composer_->InsertCharacterKeyAndPreedit("l", "\xE3\x82\x8A");
  // "ら"
  composer_->InsertCharacterKeyAndPreedit("o", "\xE3\x82\x89");

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "くいりりら"
  EXPECT_EQ("\xE3\x81\x8F\xE3\x81\x84\xE3\x82\x8A\xE3\x82\x8A\xE3\x82\x89",
            preedit);

  transliteration::Transliterations transliterations;
  composer_->GetTransliterations(&transliterations);
  EXPECT_EQ(transliteration::NUM_T13N_TYPES, transliterations.size());
  EXPECT_EQ("hello", transliterations[transliteration::HALF_ASCII]);
}

TEST_F(ComposerTest, SetOutputMode) {
  // "も"
  table_->AddRule("mo", "\xE3\x82\x82", "");
  // "ず"
  table_->AddRule("zu", "\xE3\x81\x9A", "");

  composer_->InsertCharacter("m");
  composer_->InsertCharacter("o");
  composer_->InsertCharacter("z");
  composer_->InsertCharacter("u");

  string output;
  composer_->GetStringForPreedit(&output);
  // "もず"
  EXPECT_EQ("\xE3\x82\x82\xE3\x81\x9A", output);
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->SetOutputMode(transliteration::HALF_ASCII);
  composer_->GetStringForPreedit(&output);
  EXPECT_EQ("mozu", output);
  EXPECT_EQ(4, composer_->GetCursor());

  composer_->SetOutputMode(transliteration::HALF_KATAKANA);
  composer_->GetStringForPreedit(&output);
  // "ﾓｽﾞ"
  EXPECT_EQ("\xEF\xBE\x93\xEF\xBD\xBD\xEF\xBE\x9E", output);
  EXPECT_EQ(3, composer_->GetCursor());
}

TEST_F(ComposerTest, UpdateInputMode) {
  // "あ"
  table_->AddRule("a", "\xE3\x81\x82", "");
  // "い"
  table_->AddRule("i", "\xE3\x81\x84", "");

  InsertKey("A", composer_.get());
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

  InsertKey("I", composer_.get());
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

  InsertKey("a", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  InsertKey("i", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  composer_->SetInputMode(transliteration::FULL_ASCII);
  InsertKey("a", composer_.get());
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  InsertKey("i", composer_.get());
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  string output;
  composer_->GetStringForPreedit(&output);
  // "AIあいａｉ"
  EXPECT_EQ("\x41\x49\xE3\x81\x82\xE3\x81\x84\xEF\xBD\x81\xEF\xBD\x89",
            output);

  composer_->SetInputMode(transliteration::FULL_KATAKANA);

  // "|AIあいａｉ"
  composer_->MoveCursorToBeginning();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "A|Iあいａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

  // "AI|あいａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあ|いａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  // "AIあい|ａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあいａ|ｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  // "AIあいａｉ|"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  // "AIあいａ|ｉ"
  composer_->MoveCursorLeft();
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  // "|AIあいａｉ"
  composer_->MoveCursorToBeginning();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "A|Iあいａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

  // "A|あいａｉ"
  composer_->Delete();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aあ|いａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  // "A|いａｉ"
  composer_->Backspace();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aいａｉ|"
  composer_->MoveCursorToEnd();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aいａ|ｉ"
  composer_->MoveCursorLeft();
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  // "Aいａｉ|"
  composer_->MoveCursorToEnd();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
}


TEST_F(ComposerTest, DisabledUpdateInputMode) {
  // Set the flag disable.
  commands::Request request;
  request.set_update_input_mode_from_surrounding_text(false);
  composer_->SetRequest(&request);

  // "あ"
  table_->AddRule("a", "\xE3\x81\x82", "");
  // "い"
  table_->AddRule("i", "\xE3\x81\x84", "");

  InsertKey("A", composer_.get());
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

  InsertKey("I", composer_.get());
  EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

  InsertKey("a", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  InsertKey("i", composer_.get());
  EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());

  composer_->SetInputMode(transliteration::FULL_ASCII);
  InsertKey("a", composer_.get());
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  InsertKey("i", composer_.get());
  EXPECT_EQ(transliteration::FULL_ASCII, composer_->GetInputMode());

  string output;
  composer_->GetStringForPreedit(&output);
  // "AIあいａｉ"
  EXPECT_EQ("\x41\x49\xE3\x81\x82\xE3\x81\x84\xEF\xBD\x81\xEF\xBD\x89",
            output);

  composer_->SetInputMode(transliteration::FULL_KATAKANA);

  // Use same scenario as above test case, but the result of GetInputMode
  // should be always FULL_KATAKANA regardless of the surrounding text.

  // "|AIあいａｉ"
  composer_->MoveCursorToBeginning();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "A|Iあいａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AI|あいａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあ|いａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあい|ａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあいａ|ｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあいａｉ|"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "AIあいａ|ｉ"
  composer_->MoveCursorLeft();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "|AIあいａｉ"
  composer_->MoveCursorToBeginning();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "A|Iあいａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "A|あいａｉ"
  composer_->Delete();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aあ|いａｉ"
  composer_->MoveCursorRight();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "A|いａｉ"
  composer_->Backspace();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aいａｉ|"
  composer_->MoveCursorToEnd();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aいａ|ｉ"
  composer_->MoveCursorLeft();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  // "Aいａｉ|"
  composer_->MoveCursorToEnd();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
}

TEST_F(ComposerTest, TransformCharactersForNumbers) {
  string query;

  query = "";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  query = "R2D2";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ー１"
  query = "\xE3\x83\xBC\xEF\xBC\x91";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "−１"
  EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91", query);

  // "ーー１"
  query = "\xE3\x83\xBC\xE3\x83\xBC\xEF\xBC\x91";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ー"
  query = "\xE3\x83\xBC";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ーー"
  query = "\xE3\x83\xBC\xE3\x83\xBC";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ーーーーー"
  query = "\xE3\x83\xBC\xE3\x83\xBC\xE3\x83\xBC\xE3\x83\xBC\xE3\x83\xBC";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ｗ"
  query = "\xEF\xBD\x97";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ーｗ"
  query = "\xE3\x83\xBC\xEF\xBD\x97";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ーーｗ"
  query = "\xE3\x83\xBC\xE3\x83\xBC\xEF\xBD\x97";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "@" (half-width @)
  query = "@";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ー@" (half-width @)
  query = "\xE3\x83\xBC@";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ーー@" (half-width @)
  query = "\xE3\x83\xBC\xE3\x83\xBC@";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "＠" (full-width @)
  query = "\xEF\xBC\xA0";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ー＠" (full-width @)
  query = "\xE3\x83\xBC\xEF\xBC\xA0";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "ーー＠" (full-width @)
  query = "\xE3\x83\xBC\xE3\x83\xBC\xEF\xBC\xA0";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "まじかー１"
  query = "\xE3\x81\xBE\xE3\x81\x98\xE3\x81\x8B\xE3\x83\xBC\xEF\xBC\x91";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "まじかーｗ"
  query = "\xE3\x81\xBE\xE3\x81\x98\xE3\x81\x8B\xE3\x83\xBC\xEF\xBD\x97";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "１、０"
  query = "\xEF\xBC\x91\xE3\x80\x81\xEF\xBC\x90";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "１，０"
  EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90", query);

  // "０。５"
  query = "\xEF\xBC\x90\xE3\x80\x82\xEF\xBC\x95";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "０．５"
  EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95", query);

  // "ー１、０００。５"
  query = "\xE3\x83\xBC\xEF\xBC\x91\xE3\x80\x81\xEF\xBC\x90\xEF\xBC\x90"
          "\xEF\xBC\x90\xE3\x80\x82\xEF\xBC\x95";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "−１，０００．５"
  EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90"
            "\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95",
            query);

  // "０３ー"
  query = "\xEF\xBC\x90\xEF\xBC\x93\xE3\x83\xBC";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "０３−"
  EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x93\xE2\x88\x92", query);

  // "０３ーーーーー"
  query = "\xEF\xBC\x90\xEF\xBC\x93"
      "\xE3\x83\xBC\xE3\x83\xBC\xE3\x83\xBC\xE3\x83\xBC\xE3\x83\xBC";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "０３−−−−−"
  EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x93"
            "\xE2\x88\x92\xE2\x88\x92\xE2\x88\x92\xE2\x88\x92\xE2\x88\x92",
            query);

  // "ｘー（ー１）＞ーｘ"
  query = "\xEF\xBD\x98\xE3\x83\xBC\xEF\xBC\x88\xE3\x83\xBC\xEF\xBC\x91"
          "\xEF\xBC\x89\xEF\xBC\x9E\xE3\x83\xBC\xEF\xBD\x98";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "ｘ−（−１）＞−ｘ"
  EXPECT_EQ("\xEF\xBD\x98\xE2\x88\x92\xEF\xBC\x88\xE2\x88\x92\xEF\xBC\x91"
            "\xEF\xBC\x89\xEF\xBC\x9E\xE2\x88\x92\xEF\xBD\x98",
            query);

  // "１＊ー２／ー３ーー４"
  query = "\xEF\xBC\x91\xEF\xBC\x8A\xE3\x83\xBC\xEF\xBC\x92\xEF\xBC\x8F"
          "\xE3\x83\xBC\xEF\xBC\x93\xE3\x83\xBC\xE3\x83\xBC\xEF\xBC\x94";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "１＊−２／−３−−４"
  EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x8A\xE2\x88\x92\xEF\xBC\x92\xEF\xBC\x8F"
            "\xE2\x88\x92\xEF\xBC\x93\xE2\x88\x92\xE2\x88\x92\xEF\xBC\x94",
            query);

  // "ＡーＺ"
  query = "\xEF\xBC\xA1\xE3\x83\xBC\xEF\xBC\xBA";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "Ａ−Ｚ"
  EXPECT_EQ("\xEF\xBC\xA1\xE2\x88\x92\xEF\xBC\xBA", query);

  // "もずく、うぉーきんぐ。"
  query = "\xE3\x82\x82\xE3\x81\x9A\xE3\x81\x8F\xE3\x80\x81\xE3\x81\x86"
          "\xE3\x81\x89\xE3\x83\xBC\xE3\x81\x8D\xE3\x82\x93\xE3\x81\x90"
          "\xE3\x80\x82";
  EXPECT_FALSE(Composer::TransformCharactersForNumbers(&query));

  // "えー２、９８０円！月々たった、２、９８０円？"
  query = "\xE3\x81\x88\xE3\x83\xBC\xEF\xBC\x92\xE3\x80\x81\xEF\xBC\x99"
          "\xEF\xBC\x98\xEF\xBC\x90\xE5\x86\x86\xEF\xBC\x81\xE6\x9C\x88"
          "\xE3\x80\x85\xE3\x81\x9F\xE3\x81\xA3\xE3\x81\x9F\xE3\x80\x81"
          "\xEF\xBC\x92\xE3\x80\x81\xEF\xBC\x99\xEF\xBC\x98\xEF\xBC\x90"
          "\xE5\x86\x86\xEF\xBC\x9F";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "えー２，９８０円！月々たった、２，９８０円？"
  EXPECT_EQ("\xE3\x81\x88\xE3\x83\xBC\xEF\xBC\x92\xEF\xBC\x8C\xEF\xBC\x99"
            "\xEF\xBC\x98\xEF\xBC\x90\xE5\x86\x86\xEF\xBC\x81\xE6\x9C\x88"
            "\xE3\x80\x85\xE3\x81\x9F\xE3\x81\xA3\xE3\x81\x9F\xE3\x80\x81"
            "\xEF\xBC\x92\xEF\xBC\x8C\xEF\xBC\x99\xEF\xBC\x98\xEF\xBC\x90"
            "\xE5\x86\x86\xEF\xBC\x9F",
            query);

  // "およそ、３。１４１５９。"
  query = "\xE3\x81\x8A\xE3\x82\x88\xE3\x81\x9D\xE3\x80\x81\xEF\xBC\x93"
          "\xE3\x80\x82\xEF\xBC\x91\xEF\xBC\x94\xEF\xBC\x91\xEF\xBC\x95"
          "\xEF\xBC\x99\xE3\x80\x82";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  // "およそ、３．１４１５９．"
  EXPECT_EQ("\xE3\x81\x8A\xE3\x82\x88\xE3\x81\x9D\xE3\x80\x81\xEF\xBC\x93"
            "\xEF\xBC\x8E\xEF\xBC\x91\xEF\xBC\x94\xEF\xBC\x91\xEF\xBC\x95"
            "\xEF\xBC\x99\xEF\xBC\x8E",
            query);

  // "１００、" => "１００，"
  query = "\xEF\xBC\x91\xEF\xBC\x90\xEF\xBC\x90\xE3\x80\x81";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x8C",
            query);

  // "１００。" => "１００．"
  query = "\xEF\xBC\x91\xEF\xBC\x90\xEF\xBC\x90\xE3\x80\x82";
  EXPECT_TRUE(Composer::TransformCharactersForNumbers(&query));
  EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x8E",
            query);
}

TEST_F(ComposerTest, PreeditFormAfterCharacterTransform) {
  CharacterFormManager *manager =
      CharacterFormManager::GetCharacterFormManager();
  table_->AddRule("0", "\xEF\xBC\x90", "");  // "０"
  table_->AddRule("1", "\xEF\xBC\x91", "");  // "１"
  table_->AddRule("2", "\xEF\xBC\x92", "");  // "２"
  table_->AddRule("3", "\xEF\xBC\x93", "");  // "３"
  table_->AddRule("4", "\xEF\xBC\x94", "");  // "４"
  table_->AddRule("5", "\xEF\xBC\x95", "");  // "５"
  table_->AddRule("6", "\xEF\xBC\x96", "");  // "６"
  table_->AddRule("7", "\xEF\xBC\x97", "");  // "７"
  table_->AddRule("8", "\xEF\xBC\x98", "");  // "８"
  table_->AddRule("9", "\xEF\xBC\x99", "");  // "９"
  table_->AddRule("-", "\xE3\x83\xBC", "");  // "ー"
  table_->AddRule(",", "\xE3\x80\x81", "");  // "、"
  table_->AddRule(".", "\xE3\x80\x82", "");  // "。"


  {
    composer_->Reset();
    manager->SetDefaultRule();
    manager->AddPreeditRule("1", Config::HALF_WIDTH);
    manager->AddPreeditRule(".,", Config::HALF_WIDTH);
    composer_->InsertCharacter("3.14");
    string result;
    composer_->GetStringForPreedit(&result);
    EXPECT_EQ("3.14",
              result);
  }

  {
    composer_->Reset();
    manager->SetDefaultRule();
    manager->AddPreeditRule("1", Config::FULL_WIDTH);
    manager->AddPreeditRule(".,", Config::HALF_WIDTH);
    composer_->InsertCharacter("3.14");
    string result;
    composer_->GetStringForPreedit(&result);
    // "３.１４"
    EXPECT_EQ("\xef\xbc\x93\x2e\xef\xbc\x91\xef\xbc\x94",
              result);
  }

  {
    composer_->Reset();
    manager->SetDefaultRule();
    manager->AddPreeditRule("1", Config::HALF_WIDTH);
    manager->AddPreeditRule(".,", Config::FULL_WIDTH);
    composer_->InsertCharacter("3.14");
    string result;
    composer_->GetStringForPreedit(&result);
    // "3．14"
    EXPECT_EQ("\x33\xef\xbc\x8e\x31\x34",
              result);
  }

  {
    composer_->Reset();
    manager->SetDefaultRule();
    manager->AddPreeditRule("1", Config::FULL_WIDTH);
    manager->AddPreeditRule(".,", Config::FULL_WIDTH);
    composer_->InsertCharacter("3.14");
    string result;
    composer_->GetStringForPreedit(&result);
    // "３．１４"
    EXPECT_EQ("\xef\xbc\x93\xef\xbc\x8e\xef\xbc\x91\xef\xbc\x94",
              result);
  }
}

TEST_F(ComposerTest, ComposingWithcharactertransform) {
  table_->AddRule("0", "\xEF\xBC\x90", "");  // "０"
  table_->AddRule("1", "\xEF\xBC\x91", "");  // "１"
  table_->AddRule("2", "\xEF\xBC\x92", "");  // "２"
  table_->AddRule("3", "\xEF\xBC\x93", "");  // "３"
  table_->AddRule("4", "\xEF\xBC\x94", "");  // "４"
  table_->AddRule("5", "\xEF\xBC\x95", "");  // "５"
  table_->AddRule("6", "\xEF\xBC\x96", "");  // "６"
  table_->AddRule("7", "\xEF\xBC\x97", "");  // "７"
  table_->AddRule("8", "\xEF\xBC\x98", "");  // "８"
  table_->AddRule("9", "\xEF\xBC\x99", "");  // "９"
  table_->AddRule("-", "\xE3\x83\xBC", "");  // "ー"
  table_->AddRule(",", "\xE3\x80\x81", "");  // "、"
  table_->AddRule(".", "\xE3\x80\x82", "");  // "。"
  composer_->InsertCharacter("-1,000.5");

  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "−１，０００．５"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90"
              "\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95",
              result);
  }
  {
    string result;
    composer_->GetStringForSubmission(&result);
    // "−１，０００．５"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90"
              "\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95",
              result);
  }
  {
    string result;
    composer_->GetQueryForConversion(&result);
    EXPECT_EQ("-1,000.5", result);
  }
  {
    string result;
    composer_->GetQueryForPrediction(&result);
    EXPECT_EQ("-1,000.5", result);
  }
  {
    string left, focused, right;
    // Right edge
    composer_->GetPreedit(&left, &focused, &right);
    // "−１，０００．５"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90"
              "\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95",
              left);
    EXPECT_TRUE(focused.empty());
    EXPECT_TRUE(right.empty());

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−１，０００．"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90"
              "\xEF\xBC\x90\xEF\xBC\x8E",
              left);
    // "５"
    EXPECT_EQ("\xEF\xBC\x95", focused);
    EXPECT_TRUE(right.empty());

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−１，０００"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90"
              "\xEF\xBC\x90",
              left);
    // "．"
    EXPECT_EQ("\xEF\xBC\x8E", focused);
    // "５"
    EXPECT_EQ("\xEF\xBC\x95", right);

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−１，００"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90",
              left);
    // "０"
    EXPECT_EQ("\xEF\xBC\x90", focused);
    // "．５"
    EXPECT_EQ("\xEF\xBC\x8E\xEF\xBC\x95", right);

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−１，０"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90", left);
    // "０"
    EXPECT_EQ("\xEF\xBC\x90", focused);
    // "０．５"
    EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95", right);

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−１，"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91\xEF\xBC\x8C", left);
    // "０"
    EXPECT_EQ("\xEF\xBC\x90", focused);
    // "００．５"
    EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95", right);

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−１"
    EXPECT_EQ("\xE2\x88\x92\xEF\xBC\x91", left);
    // "，"
    EXPECT_EQ("\xEF\xBC\x8C", focused);
    // "０００．５"
    EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x8E\xEF\xBC\x95",
              right);

    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    // "−"
    EXPECT_EQ("\xE2\x88\x92", left);
    // "１"
    EXPECT_EQ("\xEF\xBC\x91", focused);
    // "，０００．５"
    EXPECT_EQ("\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x8E"
              "\xEF\xBC\x95",
              right);

    // Left edge
    composer_->MoveCursorLeft();
    composer_->GetPreedit(&left, &focused, &right);
    EXPECT_TRUE(left.empty());
    // "−"
    EXPECT_EQ("\xE2\x88\x92", focused);
    // "１，０００．５"
    EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x90"
              "\xEF\xBC\x8E\xEF\xBC\x95",
              right);
  }
}

TEST_F(ComposerTest, AlphanumericOfSSH) {
  // This is a unittest against http://b/3199626
  // 'ssh' (っｓｈ) + F10 should be 'ssh'.
  table_->AddRule("ss", "[X]", "s");
  table_->AddRule("sha", "[SHA]", "");
  composer_->InsertCharacter("ssh");
  // "［Ｘ］ｓｈ"
  EXPECT_EQ("\xEF\xBC\xBB\xEF\xBC\xB8\xEF\xBC\xBD\xEF\xBD\x93\xEF\xBD\x88",
            GetPreedit(composer_.get()));

  string query;
  composer_->GetQueryForConversion(&query);
  EXPECT_EQ("[X]sh", query);

  transliteration::Transliterations t13ns;
  composer_->GetTransliterations(&t13ns);
  EXPECT_EQ("ssh", t13ns[transliteration::HALF_ASCII]);
}

TEST_F(ComposerTest, Issue2190364) {
  // This is a unittest against http://b/2190364
  commands::KeyEvent key;
  key.set_key_code('a');
  // "ち"
  key.set_key_string("\xE3\x81\xA1");

  // Toggle the input mode to HALF_ASCII
  composer_->ToggleInputMode();
  EXPECT_TRUE(composer_->InsertCharacterKeyEvent(key));
  string output;
  composer_->GetStringForPreedit(&output);
  EXPECT_EQ("a", output);

  // Insertion of a space and backspace it should not change the composition.
  composer_->InsertCharacter(" ");
  output.clear();
  composer_->GetStringForPreedit(&output);
  EXPECT_EQ("a ", output);

  composer_->Backspace();
  output.clear();
  composer_->GetStringForPreedit(&output);
  EXPECT_EQ("a", output);

  // Toggle the input mode to HIRAGANA, the preedit should not be changed.
  composer_->ToggleInputMode();
  output.clear();
  composer_->GetStringForPreedit(&output);
  EXPECT_EQ("a", output);

  // "a" should be converted to "ち" on Hiragana input mode.
  EXPECT_TRUE(composer_->InsertCharacterKeyEvent(key));
  output.clear();
  composer_->GetStringForPreedit(&output);
  // "aち"
  EXPECT_EQ("a\xE3\x81\xA1", output);
}

TEST_F(ComposerTest, Issue1817410) {
  // This is a unittest against http://b/2190364
  // "っ"
  table_->AddRule("ss", "\xE3\x81\xA3", "s");

  InsertKey("s", composer_.get());
  InsertKey("s", composer_.get());

  string preedit;
  composer_->GetStringForPreedit(&preedit);
  // "っｓ"
  EXPECT_EQ("\xE3\x81\xA3\xEF\xBD\x93", preedit);

  string t13n;
  composer_->GetSubTransliteration(transliteration::HALF_ASCII, 0, 2, &t13n);
  EXPECT_EQ("ss", t13n);

  t13n.clear();
  composer_->GetSubTransliteration(transliteration::HALF_ASCII, 0, 1, &t13n);
  EXPECT_EQ("s", t13n);

  t13n.clear();
  composer_->GetSubTransliteration(transliteration::HALF_ASCII, 1, 1, &t13n);
  EXPECT_EQ("s", t13n);
}

TEST_F(ComposerTest, Issue2272745) {
  // This is a unittest against http://b/2272745.
  // A temporary input mode remains when a composition is canceled.
  {
    InsertKey("G", composer_.get());
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    composer_->Backspace();
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }
  composer_->Reset();
  {
    InsertKey("G", composer_.get());
    EXPECT_EQ(transliteration::HALF_ASCII, composer_->GetInputMode());

    composer_->EditErase();
    EXPECT_EQ(transliteration::HIRAGANA, composer_->GetInputMode());
  }
}

TEST_F(ComposerTest, Isue2555503) {
  // This is a unittest against http://b/2555503.
  // Mode respects the previous character too much.
  InsertKey("a", composer_.get());
  composer_->SetInputMode(transliteration::FULL_KATAKANA);
  InsertKey("i", composer_.get());
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());

  composer_->Backspace();
  EXPECT_EQ(transliteration::FULL_KATAKANA, composer_->GetInputMode());
}

TEST_F(ComposerTest, Issue2819580_1) {
  // This is a unittest against http://b/2819580.
  // 'y' after 'n' disappears.
  // "ん"
  table_->AddRule("n", "\xe3\x82\x93", "");
  // "な"
  table_->AddRule("na", "\xe3\x81\xaa", "");
  // "や"
  table_->AddRule("ya", "\xe3\x82\x84", "");
  // "にゃ"
  table_->AddRule("nya", "\xe3\x81\xab\xe3\x82\x83", "");

  InsertKey("n", composer_.get());
  InsertKey("y", composer_.get());

  string result;
  composer_->GetQueryForConversion(&result);
  // "んy"
  EXPECT_EQ("\xe3\x82\x93y", result);
}

TEST_F(ComposerTest, Issue2819580_2) {
  // This is a unittest against http://b/2819580.
  // 'y' after 'n' disappears.
  // "ぽ"
  table_->AddRule("po", "\xe3\x81\xbd", "");
  // "ん"
  table_->AddRule("n", "\xe3\x82\x93", "");
  // "な"
  table_->AddRule("na", "\xe3\x81\xaa", "");
  // "や"
  table_->AddRule("ya", "\xe3\x82\x84", "");
  // "にゃ"
  table_->AddRule("nya", "\xe3\x81\xab\xe3\x82\x83", "");

  InsertKey("p", composer_.get());
  InsertKey("o", composer_.get());
  InsertKey("n", composer_.get());
  InsertKey("y", composer_.get());

  string result;
  composer_->GetQueryForConversion(&result);
  // "ぽんy"
  EXPECT_EQ("\xe3\x81\xbd\xe3\x82\x93y", result);
}

TEST_F(ComposerTest, Issue2819580_3) {
  // This is a unittest against http://b/2819580.
  // 'y' after 'n' disappears.
  // "ん"
  table_->AddRule("n", "\xe3\x82\x93", "");
  // "な"
  table_->AddRule("na", "\xe3\x81\xaa", "");
  // "や"
  table_->AddRule("ya", "\xe3\x82\x84", "");
  // "にゃ"
  table_->AddRule("nya", "\xe3\x81\xab\xe3\x82\x83", "");

  InsertKey("z", composer_.get());
  InsertKey("n", composer_.get());
  InsertKey("y", composer_.get());

  string result;
  composer_->GetQueryForConversion(&result);
  // "zんy"
  EXPECT_EQ("z\xe3\x82\x93y", result);
}

TEST_F(ComposerTest, Issue2797991_1) {
  // This is a unittest against http://b/2797991.
  // Half-width alphanumeric mode quits after [CAPITAL LETTER]:[CAPITAL LETTER]
  // e.g. C:\Wi -> C:\Wい

  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");

  InsertKey("C", composer_.get());
  InsertKey(":", composer_.get());
  InsertKey("\\", composer_.get());
  InsertKey("W", composer_.get());
  InsertKey("i", composer_.get());

  string result;
  composer_->GetStringForPreedit(&result);
  EXPECT_EQ("C:\\Wi", result);
}

TEST_F(ComposerTest, Issue2797991_2) {
  // This is a unittest against http://b/2797991.
  // Half-width alphanumeric mode quits after [CAPITAL LETTER]:[CAPITAL LETTER]
  // e.g. C:\Wi -> C:\Wい

  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");

  InsertKey("C", composer_.get());
  InsertKey(":", composer_.get());
  InsertKey("W", composer_.get());
  InsertKey("i", composer_.get());

  string result;
  composer_->GetStringForPreedit(&result);
  EXPECT_EQ("C:Wi", result);
}

TEST_F(ComposerTest, Issue2797991_3) {
  // This is a unittest against http://b/2797991.
  // Half-width alphanumeric mode quits after [CAPITAL LETTER]:[CAPITAL LETTER]
  // e.g. C:\Wi -> C:\Wい

  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");

  InsertKey("C", composer_.get());
  InsertKey(":", composer_.get());
  InsertKey("\\", composer_.get());
  InsertKey("W", composer_.get());
  InsertKey("i", composer_.get());
  InsertKeyWithMode("i", commands::HIRAGANA, composer_.get());
  string result;
  composer_->GetStringForPreedit(&result);
  // "C:\Wiい"
  EXPECT_EQ("C:\\Wi\xe3\x81\x84", result);
}

TEST_F(ComposerTest, Issue2797991_4) {
  // This is a unittest against http://b/2797991.
  // Half-width alphanumeric mode quits after [CAPITAL LETTER]:[CAPITAL LETTER]
  // e.g. C:\Wi -> C:\Wい

  // "い"
  table_->AddRule("i", "\xe3\x81\x84", "");

  InsertKey("c", composer_.get());
  InsertKey(":", composer_.get());
  InsertKey("\\", composer_.get());
  InsertKey("W", composer_.get());
  InsertKey("i", composer_.get());

  string result;
  composer_->GetStringForPreedit(&result);
  EXPECT_EQ("c:\\Wi", result);
}

TEST_F(ComposerTest, CaseSensitiveByConfiguration) {
  {
    Config config;
    ConfigHandler::GetDefaultConfig(&config);
    config.set_shift_key_mode_switch(Config::OFF);
    ConfigHandler::SetConfig(config);
    EXPECT_TRUE(ConfigHandler::SetConfig(config));
    table_->InitializeWithRequestAndConfig(*default_request_, config);

    // i -> "い"
    table_->AddRule("i", "\xe3\x81\x84", "");
    // I -> "イ"
    table_->AddRule("I", "\xe3\x82\xa4", "");

    InsertKey("i", composer_.get());
    InsertKey("I", composer_.get());
    InsertKey("i", composer_.get());
    InsertKey("I", composer_.get());
    string result;
    composer_->GetStringForPreedit(&result);
    // "いイいイ"
    EXPECT_EQ("\xe3\x81\x84\xe3\x82\xa4\xe3\x81\x84\xe3\x82\xa4", result);
  }
  composer_->Reset();
  {
    Config config;
    ConfigHandler::GetDefaultConfig(&config);
    config.set_shift_key_mode_switch(Config::ASCII_INPUT_MODE);
    ConfigHandler::SetConfig(config);
    EXPECT_TRUE(ConfigHandler::SetConfig(config));
    table_->InitializeWithRequestAndConfig(*default_request_, config);

    // i -> "い"
    table_->AddRule("i", "\xe3\x81\x84", "");
    // I -> "イ"
    table_->AddRule("I", "\xe3\x82\xa4", "");

    InsertKey("i", composer_.get());
    InsertKey("I", composer_.get());
    InsertKey("i", composer_.get());
    InsertKey("I", composer_.get());
    string result;
    composer_->GetStringForPreedit(&result);
    // "いIiI"
    EXPECT_EQ("\xe3\x81\x84IiI", result);
  }
}

TEST_F(ComposerTest,
       InputUppercaseInAlphanumericModeWithShiftKeyModeSwitchIsKatakana) {
  {
    Config config;
    ConfigHandler::GetDefaultConfig(&config);
    config.set_shift_key_mode_switch(Config::KATAKANA_INPUT_MODE);
    ConfigHandler::SetConfig(config);
    EXPECT_TRUE(ConfigHandler::SetConfig(config));
    table_->InitializeWithRequestAndConfig(*default_request_, config);

    // i -> "い"
    table_->AddRule("i", "\xe3\x81\x84", "");
    // I -> "イ"
    table_->AddRule("I", "\xe3\x82\xa4", "");

    {
      composer_->Reset();
      composer_->SetInputMode(transliteration::FULL_ASCII);
      InsertKey("I", composer_.get());
      string result;
      composer_->GetStringForPreedit(&result);
      // "Ｉ"
      EXPECT_EQ("\xef\xbc\xa9", result);
    }

    {
      composer_->Reset();
      composer_->SetInputMode(transliteration::HALF_ASCII);
      InsertKey("I", composer_.get());
      string result;
      composer_->GetStringForPreedit(&result);
      EXPECT_EQ("I", result);
    }

    {
      composer_->Reset();
      composer_->SetInputMode(transliteration::FULL_KATAKANA);
      InsertKey("I", composer_.get());
      string result;
      composer_->GetStringForPreedit(&result);
      // "イ"
      EXPECT_EQ("\xe3\x82\xa4", result);
    }

    {
      composer_->Reset();
      composer_->SetInputMode(transliteration::HALF_KATAKANA);
      InsertKey("I", composer_.get());
      string result;
      composer_->GetStringForPreedit(&result);
      // "ｲ"
      EXPECT_EQ("\xEF\xBD\xB2", result);
    }

    {
      composer_->Reset();
      composer_->SetInputMode(transliteration::HIRAGANA);
      InsertKey("I", composer_.get());
      string result;
      composer_->GetStringForPreedit(&result);
      // "イ"
      EXPECT_EQ("\xe3\x82\xa4", result);
    }
  }
}

TEST_F(ComposerTest,
       DeletingAlphanumericPartShouldQuitToggleAlphanumericMode) {
  // http://b/2206560
  // 1. Type "iGoogle" (preedit text turns to be "いGoogle")
  // 2. Type Back-space 6 times ("い")
  // 3. Type "i" (should be "いい")

  config::Config config;
  table_->InitializeWithRequestAndConfig(*default_request_, config);

  // i -> "い"
  table_->AddRule("i", "\xe3\x81\x84", "");

  InsertKey("i", composer_.get());
  InsertKey("G", composer_.get());
  InsertKey("o", composer_.get());
  InsertKey("o", composer_.get());
  InsertKey("g", composer_.get());
  InsertKey("l", composer_.get());
  InsertKey("e", composer_.get());

  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "いGoogle"
    EXPECT_EQ("\xe3\x81\x84Google", result);
  }

  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();

  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "い"
    EXPECT_EQ("\xe3\x81\x84", result);
  }

  InsertKey("i", composer_.get());

  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "いい"
    EXPECT_EQ("\xe3\x81\x84\xe3\x81\x84", result);
  }
}

TEST_F(ComposerTest, InputModesChangeWhenCursorMoves) {
  // The expectation of this test is the same as MS-IME's

  config::Config config;
  table_->InitializeWithRequestAndConfig(*default_request_, config);

  // i -> "い"
  table_->AddRule("i", "\xe3\x81\x84", "");
  // gi -> "ぎ"
  table_->AddRule("gi", "\xe3\x81\x8e", "");

  InsertKey("i", composer_.get());
  composer_->MoveCursorRight();
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "い"
    EXPECT_EQ("\xe3\x81\x84", result);
  }

  composer_->MoveCursorLeft();
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "い"
    EXPECT_EQ("\xe3\x81\x84", result);
  }

  InsertKey("G", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "Gい"
    EXPECT_EQ("G\xe3\x81\x84", result);
  }

  composer_->MoveCursorRight();
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "Gい"
    EXPECT_EQ("G\xe3\x81\x84", result);
  }

  InsertKey("G", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "GいG"
    EXPECT_EQ("G\xe3\x81\x84G", result);
  }

  composer_->MoveCursorLeft();
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "GいいG"
    EXPECT_EQ("G\xe3\x81\x84\xe3\x81\x84G", result);
  }

  composer_->MoveCursorRight();
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "GいいGi"
    EXPECT_EQ("G\xe3\x81\x84\xe3\x81\x84Gi", result);
  }

  InsertKey("G", composer_.get());
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "GいいGiGi"
    EXPECT_EQ("G\xe3\x81\x84\xe3\x81\x84GiGi", result);
  }

  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "GいいGi"
    EXPECT_EQ("G\xe3\x81\x84\xe3\x81\x84Gi", result);
  }

  InsertKey("G", composer_.get());
  InsertKey("G", composer_.get());
  composer_->MoveCursorRight();
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "GいいGiGGi"
    EXPECT_EQ("G\xe3\x81\x84\xe3\x81\x84GiGGi", result);
  }

  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  composer_->Backspace();
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "Gい"
    EXPECT_EQ("G\xe3\x81\x84", result);
  }

  composer_->Backspace();
  composer_->MoveCursorLeft();
  composer_->MoveCursorRight();
  InsertKey("i", composer_.get());
  {
    string result;
    composer_->GetStringForPreedit(&result);
    // "Gi"
    EXPECT_EQ("Gi", result);
  }
}

TEST_F(ComposerTest, ShuoldCommit) {
  table_->AddRuleWithAttributes("ka", "[KA]", "", DIRECT_INPUT);
  table_->AddRuleWithAttributes("tt", "[X]", "t", DIRECT_INPUT);
  table_->AddRuleWithAttributes("ta", "[TA]", "", NO_TABLE_ATTRIBUTE);

  // k
  composer_->InsertCharacter("k");
  EXPECT_FALSE(composer_->ShouldCommit());

  // k + a
  composer_->InsertCharacter("a");
  EXPECT_TRUE(composer_->ShouldCommit());

  // ka + t
  composer_->InsertCharacter("t");
  EXPECT_FALSE(composer_->ShouldCommit());

  // kat + t
  composer_->InsertCharacter("t");
  EXPECT_FALSE(composer_->ShouldCommit());

  // katt + a
  composer_->InsertCharacter("a");
  EXPECT_TRUE(composer_->ShouldCommit());

  // katta + t
  composer_->InsertCharacter("t");
  EXPECT_FALSE(composer_->ShouldCommit());

  // kattat + a
  composer_->InsertCharacter("a");
  EXPECT_FALSE(composer_->ShouldCommit());
}

TEST_F(ComposerTest, ShouldCommitHead) {
  struct TestData {
    const string input_text;
    const commands::Context::InputFieldType field_type;
    const bool expected_return;
    const size_t expected_commit_length;
    TestData(const string &input_text,
             commands::Context::InputFieldType field_type,
             bool expected_return,
             size_t expected_commit_length)
        : input_text(input_text),
          field_type(field_type),
          expected_return(expected_return),
          expected_commit_length(expected_commit_length) {
    }
  };
  const TestData test_data_list[] = {
      // On NORMAL, never commit the head.
      TestData("", commands::Context::NORMAL, false, 0),
      TestData("A", commands::Context::NORMAL, false, 0),
      TestData("AB", commands::Context::NORMAL, false, 0),
      TestData("", commands::Context::PASSWORD, false, 0),
      // On PASSWORD, commit (length - 1) characters.
      TestData("A", commands::Context::PASSWORD, false, 0),
      TestData("AB", commands::Context::PASSWORD, true, 1),
      TestData("ABCDEFGHI", commands::Context::PASSWORD, true, 8),
      // On NUMBER and TEL, commit (length) characters.
      TestData("", commands::Context::NUMBER, false, 0),
      TestData("A", commands::Context::NUMBER, true, 1),
      TestData("AB", commands::Context::NUMBER, true, 2),
      TestData("ABCDEFGHI", commands::Context::NUMBER, true, 9),
      TestData("", commands::Context::TEL, false, 0),
      TestData("A", commands::Context::TEL, true, 1),
      TestData("AB", commands::Context::TEL, true, 2),
      TestData("ABCDEFGHI", commands::Context::TEL, true, 9),
  };

  for (size_t i = 0; i < arraysize(test_data_list); ++i) {
    const TestData &test_data = test_data_list[i];
    SCOPED_TRACE(test_data.input_text);
    SCOPED_TRACE(test_data.field_type);
    SCOPED_TRACE(test_data.expected_return);
    SCOPED_TRACE(test_data.expected_commit_length);
    composer_->Reset();
    composer_->SetInputFieldType(test_data.field_type);
    composer_->InsertCharacter(test_data.input_text);
    size_t length_to_commit;
    const bool result = composer_->ShouldCommitHead(&length_to_commit);
    if (test_data.expected_return) {
      EXPECT_TRUE(result);
      EXPECT_EQ(test_data.expected_commit_length, length_to_commit);
    } else {
      EXPECT_FALSE(result);
    }
  }
}

TEST_F(ComposerTest, CursorMovements) {
  composer_->InsertCharacter("mozuku");
  EXPECT_EQ(6, composer_->GetLength());
  EXPECT_EQ(6, composer_->GetCursor());

  composer_->MoveCursorRight();
  EXPECT_EQ(6, composer_->GetCursor());
  composer_->MoveCursorLeft();
  EXPECT_EQ(5, composer_->GetCursor());

  composer_->MoveCursorToBeginning();
  EXPECT_EQ(0, composer_->GetCursor());
  composer_->MoveCursorLeft();
  EXPECT_EQ(0, composer_->GetCursor());
  composer_->MoveCursorRight();
  EXPECT_EQ(1, composer_->GetCursor());

  composer_->MoveCursorTo(0);
  EXPECT_EQ(0, composer_->GetCursor());
  composer_->MoveCursorTo(6);
  EXPECT_EQ(6, composer_->GetCursor());
  composer_->MoveCursorTo(3);
  EXPECT_EQ(3, composer_->GetCursor());
  composer_->MoveCursorTo(10);
  EXPECT_EQ(3, composer_->GetCursor());
  composer_->MoveCursorTo(-1);
  EXPECT_EQ(3, composer_->GetCursor());
}

TEST_F(ComposerTest, SourceText) {
  composer_->SetInputMode(transliteration::HALF_ASCII);
  composer_->InsertCharacterPreedit("mozc");
  composer_->mutable_source_text()->assign("MOZC");
  EXPECT_FALSE(composer_->Empty());
  EXPECT_EQ("mozc", GetPreedit(composer_.get()));
  EXPECT_EQ("MOZC", composer_->source_text());

  composer_->Backspace();
  composer_->Backspace();
  EXPECT_FALSE(composer_->Empty());
  EXPECT_EQ("mo", GetPreedit(composer_.get()));
  EXPECT_EQ("MOZC", composer_->source_text());

  composer_->Reset();
  EXPECT_TRUE(composer_->Empty());
  EXPECT_TRUE(composer_->source_text().empty());
}

TEST_F(ComposerTest, DeleteAt) {
  // "も"
  table_->AddRule("mo", "\xE3\x82\x82", "");
  // "ず"
  table_->AddRule("zu", "\xE3\x81\x9a", "");

  composer_->InsertCharacter("z");
  // "ｚ"
  EXPECT_EQ("\xef\xbd\x9a", GetPreedit(composer_.get()));
  EXPECT_EQ(1, composer_->GetCursor());
  composer_->DeleteAt(0);
  EXPECT_EQ("", GetPreedit(composer_.get()));
  EXPECT_EQ(0, composer_->GetCursor());

  composer_->InsertCharacter("mmoz");
  // "ｍもｚ"
  EXPECT_EQ("\xef\xbd\x8d\xe3\x82\x82\xef\xbd\x9a",
            GetPreedit(composer_.get()));
  EXPECT_EQ(3, composer_->GetCursor());
  composer_->DeleteAt(0);
  // "もｚ"
  EXPECT_EQ("\xe3\x82\x82\xef\xbd\x9a", GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());
  composer_->InsertCharacter("u");
  // "もず"
  EXPECT_EQ("\xe3\x82\x82\xe3\x81\x9a", GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->InsertCharacter("m");
  // "もずｍ"
  EXPECT_EQ("\xe3\x82\x82\xe3\x81\x9a\xef\xbd\x8d",
            GetPreedit(composer_.get()));
  EXPECT_EQ(3, composer_->GetCursor());
  composer_->DeleteAt(1);
  // "もｍ"
  EXPECT_EQ("\xe3\x82\x82\xef\xbd\x8d", GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());
  composer_->InsertCharacter("o");
  // "もも"
  EXPECT_EQ("\xe3\x82\x82\xe3\x82\x82", GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());
}

TEST_F(ComposerTest, DeleteRange) {
  // "も"
  table_->AddRule("mo", "\xE3\x82\x82", "");
  // "ず"
  table_->AddRule("zu", "\xE3\x81\x9a", "");

  composer_->InsertCharacter("z");
  // "ｚ"
  EXPECT_EQ("\xef\xbd\x9a", GetPreedit(composer_.get()));
  EXPECT_EQ(1, composer_->GetCursor());

  composer_->DeleteRange(0, 1);
  EXPECT_EQ("", GetPreedit(composer_.get()));
  EXPECT_EQ(0, composer_->GetCursor());

  composer_->InsertCharacter("mmozmoz");
  // "ｍもｚもｚ"
  EXPECT_EQ("\xef\xbd\x8d\xe3\x82\x82\xef\xbd\x9a\xe3\x82\x82\xef\xbd\x9a",
            GetPreedit(composer_.get()));
  EXPECT_EQ(5, composer_->GetCursor());

  composer_->DeleteRange(0, 3);
  // "もｚ"
  EXPECT_EQ("\xe3\x82\x82\xef\xbd\x9a", GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->InsertCharacter("u");
  // "もず"
  EXPECT_EQ("\xe3\x82\x82\xe3\x81\x9a", GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->InsertCharacter("xyz");
  composer_->MoveCursorToBeginning();
  composer_->InsertCharacter("mom");
  // "もｍ|もずｘｙｚ"
  EXPECT_EQ("\xe3\x82\x82\xef\xbd\x8d\xe3\x82\x82\xe3\x81\x9a"
            "\xef\xbd\x98\xef\xbd\x99\xef\xbd\x9a",
            GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->DeleteRange(2, 3);
  // "もｍ|ｙｚ"
  EXPECT_EQ("\xe3\x82\x82\xef\xbd\x8d\xef\xbd\x99\xef\xbd\x9a",
            GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->InsertCharacter("o");
  // "もも|ｙｚ"
  EXPECT_EQ("\xe3\x82\x82\xe3\x82\x82\xef\xbd\x99\xef\xbd\x9a",
            GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());

  composer_->DeleteRange(2, 1000);
  // "もも|"
  EXPECT_EQ("\xe3\x82\x82\xe3\x82\x82",
            GetPreedit(composer_.get()));
  EXPECT_EQ(2, composer_->GetCursor());
}

TEST_F(ComposerTest, 12KeysAsciiGetQueryForPrediction) {
  // http://b/5509480
  commands::Request request;
  request.set_zero_query_suggestion(true);
  request.set_mixed_conversion(true);
  request.set_combine_all_segments(true);
  request.set_special_romanji_table(
      commands::Request::TWELVE_KEYS_TO_HALFWIDTHASCII);
  composer_->SetRequest(&request);
  table_->InitializeWithRequestAndConfig(request,
                                         config::ConfigHandler::GetConfig());
  composer_->InsertCharacter("2");
  EXPECT_EQ("a", GetPreedit(composer_.get()));
  string result;
  composer_->GetQueryForConversion(&result);
  EXPECT_EQ("a", result);
  result.clear();
  composer_->GetQueryForPrediction(&result);
  EXPECT_EQ("a", result);
}

TEST_F(ComposerTest, InsertCharacterPreedit) {
  // "ああaｋka。"
  const char kTestStr[] =
      "\xe3\x81\x82\xe3\x81\x82\x61\xef\xbd\x8b\x6b\x61\xe3\x80\x82";

  {
    string preedit;
    string conversion_query;
    string prediction_query;
    string base;
    set<string> expanded;
    composer_->InsertCharacterPreedit(kTestStr);
    composer_->GetStringForPreedit(&preedit);
    composer_->GetQueryForConversion(&conversion_query);
    composer_->GetQueryForPrediction(&prediction_query);
    composer_->GetQueriesForPrediction(&base, &expanded);
    EXPECT_FALSE(preedit.empty());
    EXPECT_FALSE(conversion_query.empty());
    EXPECT_FALSE(prediction_query.empty());
    EXPECT_FALSE(base.empty());
  }
  composer_->Reset();
  {
    string preedit;
    string conversion_query;
    string prediction_query;
    string base;
    set<string> expanded;
    vector<string> chars;
    Util::SplitStringToUtf8Chars(kTestStr, &chars);
    for (size_t i = 0; i < chars.size(); ++i) {
      composer_->InsertCharacterPreedit(chars[i]);
    }
    composer_->GetStringForPreedit(&preedit);
    composer_->GetQueryForConversion(&conversion_query);
    composer_->GetQueryForPrediction(&prediction_query);
    composer_->GetQueriesForPrediction(&base, &expanded);
    EXPECT_FALSE(preedit.empty());
    EXPECT_FALSE(conversion_query.empty());
    EXPECT_FALSE(prediction_query.empty());
    EXPECT_FALSE(base.empty());
  }
}

namespace {
ProbableKeyEvents GetStubProbableKeyEvent(int key_code, double probability) {
  ProbableKeyEvents result;
  ProbableKeyEvent *event;
  event = result.Add();
  event->set_key_code(key_code);
  event->set_probability(probability);
  event = result.Add();
  event->set_key_code('z');
  event->set_probability(1.0f - probability);
  return result;
}
}  // namespace

class MockTypingModel : public TypingModel {
 public:
  MockTypingModel() : TypingModel(NULL, 0, NULL, 0, NULL) {}
  virtual ~MockTypingModel() {}
  virtual int GetCost(StringPiece key) const {
    return 10;
  }
};

// Test fixture for setting up mobile qwerty romaji table to test typing
// corrector inside composer.
class TypingCorrectionTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir);

    ConfigHandler::GetConfig(&config_backup_);

    Config config;
    ConfigHandler::GetDefaultConfig(&config);
    config.set_use_typing_correction(true);
    ConfigHandler::SetConfig(config);

    table_.reset(new Table);
    table_->LoadFromFile("system://qwerty_mobile-hiragana.tsv");

    request_.reset(new Request);
    request_->set_special_romanji_table(Request::QWERTY_MOBILE_TO_HIRAGANA);

    composer_.reset(new Composer(table_.get(), request_.get()));

    table_->typing_model_ = Singleton<MockTypingModel>::get();
  }

  virtual void TearDown() {
    ConfigHandler::SetConfig(config_backup_);
  }

  static bool IsTypingCorrectorClearedOrInvalidated(const Composer &composer) {
    vector<TypeCorrectedQuery> queries;
    composer.GetTypeCorrectedQueriesForPrediction(&queries);
    return queries.empty();
  }

  scoped_ptr<Request> request_;
  scoped_ptr<Composer> composer_;
  scoped_ptr<Table> table_;
  Config config_backup_;
};

TEST_F(TypingCorrectionTest, ResetAfterComposerReset) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->Reset();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterDeleteAt) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->DeleteAt(0);
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterDelete) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->Delete();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterDeleteRange) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->DeleteRange(0, 1);
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, ResetAfterEditErase) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->EditErase();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterBackspace) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->Backspace();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterMoveCursorLeft) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->MoveCursorLeft();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterMoveCursorRight) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->MoveCursorRight();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterMoveCursorToBeginning) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->MoveCursorToBeginning();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterMoveCursorToEnd) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->MoveCursorToEnd();
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, InvalidateAfterMoveCursorTo) {
  composer_->InsertCharacterForProbableKeyEvents(
      "a",
      GetStubProbableKeyEvent('a', 0.9f));
  composer_->InsertCharacterForProbableKeyEvents(
      "b",
      GetStubProbableKeyEvent('a', 0.9f));
  EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  composer_->MoveCursorTo(0);
  EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
}

TEST_F(TypingCorrectionTest, GetTypeCorrectedQueriesForPrediction) {
  // This test only checks if typing correction candidates are nonempty after
  // each key insertion. The quality of typing correction depends on data model
  // and is tested in composer/internal/typing_corrector_test.cc.
  const char *kKeys[] = { "m", "o", "z", "u", "k", "u" };
  for (size_t i = 0; i < arraysize(kKeys); ++i) {
    composer_->InsertCharacterForProbableKeyEvents(
        kKeys[i],
        GetStubProbableKeyEvent(kKeys[i][0], 0.9f));
    EXPECT_FALSE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  }
  composer_->Backspace();
  for (size_t i = 0; i < arraysize(kKeys); ++i) {
    composer_->InsertCharacterForProbableKeyEvents(kKeys[i],
                                                   ProbableKeyEvents());
    EXPECT_TRUE(IsTypingCorrectorClearedOrInvalidated(*composer_));
  }
}

TEST_F(ComposerTest, GetRawString) {
  // "さ"
  table_->AddRule("sa", "\xE3\x81\x95", "");
  // "し"
  table_->AddRule("shi", "\xE3\x81\x97", "");
  // "み"
  table_->AddRule("mi", "\xE3\x81\xBF", "");

  composer_->SetOutputMode(transliteration::HIRAGANA);

  composer_->InsertCharacter("sashimi");

  string output;
  composer_->GetStringForPreedit(&output);
  // "さしみ"
  EXPECT_EQ("\xE3\x81\x95\xE3\x81\x97\xE3\x81\xBF", output);

  string raw_string;
  composer_->GetRawString(&raw_string);
  EXPECT_EQ("sashimi", raw_string);

  string raw_sub_string;
  composer_->GetRawSubString(0, 2, &raw_sub_string);
  EXPECT_EQ("sashi", raw_sub_string);

  composer_->GetRawSubString(1, 1, &raw_sub_string);
  EXPECT_EQ("shi", raw_sub_string);
}

}  // namespace composer
}  // namespace mozc