src/composer/internal/typing_corrector_test.cc - mozc - Git at Google

 // 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/internal/typing_corrector.h"

 #include <string>
 #include <vector>
 #include "base/singleton.h"
 #include "config/config_handler.h"
 #include "composer/table.h"
 #include "composer/type_corrected_query.h"
 #include "composer/internal/typing_model.h"
 #include "session/commands.pb.h"
 #include "testing/base/public/gunit.h"

 namespace mozc {
 namespace composer {

 namespace {
 #include "composer/internal/typing_model_qwerty_mobile-hiragana.h"
 }

 using mozc::config::Config;
 using mozc::config::ConfigHandler;

 // Embedded cost for testing purpose.
 class CostTableForTest {
  public:
   typedef map<StringPiece, ProbableKeyEvents> CorrectionTable;

   CostTableForTest() {
     {
       ProbableKeyEvents *v = &table_["a"];
       AddProbableKeyEvent('a', 0.99, v);
       AddProbableKeyEvent('q', 0.003, v);
       AddProbableKeyEvent('w', 0.003, v);
       AddProbableKeyEvent('s', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["b"];
       AddProbableKeyEvent('b', 0.99, v);
       AddProbableKeyEvent('v', 0.0025, v);
       AddProbableKeyEvent('h', 0.0025, v);
       AddProbableKeyEvent('j', 0.0025, v);
       AddProbableKeyEvent('n', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["c"];
       AddProbableKeyEvent('c', 0.99, v);
       AddProbableKeyEvent('x', 0.0025, v);
       AddProbableKeyEvent('f', 0.0025, v);
       AddProbableKeyEvent('g', 0.0025, v);
       AddProbableKeyEvent('v', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["d"];
       AddProbableKeyEvent('d', 0.99, v);
       AddProbableKeyEvent('s', 0.002, v);
       AddProbableKeyEvent('e', 0.002, v);
       AddProbableKeyEvent('f', 0.002, v);
       AddProbableKeyEvent('x', 0.002, v);
       AddProbableKeyEvent('z', 0.002, v);
     }
     {
       ProbableKeyEvents *v = &table_["e"];
       AddProbableKeyEvent('e', 0.99, v);
       AddProbableKeyEvent('w', 0.003, v);
       AddProbableKeyEvent('d', 0.003, v);
       AddProbableKeyEvent('r', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["f"];
       AddProbableKeyEvent('f', 0.99, v);
       AddProbableKeyEvent('d', 0.002, v);
       AddProbableKeyEvent('r', 0.002, v);
       AddProbableKeyEvent('g', 0.002, v);
       AddProbableKeyEvent('c', 0.002, v);
       AddProbableKeyEvent('x', 0.002, v);
     }
     {
       ProbableKeyEvents *v = &table_["g"];
       AddProbableKeyEvent('g', 0.99, v);
       AddProbableKeyEvent('f', 0.002, v);
       AddProbableKeyEvent('t', 0.002, v);
       AddProbableKeyEvent('h', 0.002, v);
       AddProbableKeyEvent('v', 0.002, v);
       AddProbableKeyEvent('c', 0.002, v);
     }
     {
       ProbableKeyEvents *v = &table_["h"];
       AddProbableKeyEvent('h', 0.99, v);
       AddProbableKeyEvent('g', 0.002, v);
       AddProbableKeyEvent('y', 0.002, v);
       AddProbableKeyEvent('j', 0.002, v);
       AddProbableKeyEvent('b', 0.002, v);
       AddProbableKeyEvent('v', 0.002, v);
     }
     {
       ProbableKeyEvents *v = &table_["i"];
       AddProbableKeyEvent('i', 0.99, v);
       AddProbableKeyEvent('u', 0.003, v);
       AddProbableKeyEvent('k', 0.003, v);
       AddProbableKeyEvent('o', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["j"];
       AddProbableKeyEvent('j', 0.99, v);
       AddProbableKeyEvent('h', 0.002, v);
       AddProbableKeyEvent('k', 0.002, v);
       AddProbableKeyEvent('u', 0.002, v);
       AddProbableKeyEvent('n', 0.002, v);
       AddProbableKeyEvent('b', 0.002, v);
     }
     {
       ProbableKeyEvents *v = &table_["k"];
       AddProbableKeyEvent('k', 0.99, v);
       AddProbableKeyEvent('j', 0.002, v);
       AddProbableKeyEvent('i', 0.002, v);
       AddProbableKeyEvent('l', 0.002, v);
       AddProbableKeyEvent('m', 0.002, v);
       AddProbableKeyEvent('n', 0.002, v);
     }
     {
       ProbableKeyEvents *v = &table_["l"];
       AddProbableKeyEvent('l', 0.99, v);
       AddProbableKeyEvent('k', 0.0025, v);
       AddProbableKeyEvent('-', 0.0025, v);
       AddProbableKeyEvent('p', 0.0025, v);
       AddProbableKeyEvent('o', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["m"];
       AddProbableKeyEvent('m', 0.99, v);
       AddProbableKeyEvent('n', 0.003, v);
       AddProbableKeyEvent('k', 0.003, v);
       AddProbableKeyEvent('l', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["n"];
       AddProbableKeyEvent('n', 0.99, v);
       AddProbableKeyEvent('b', 0.0025, v);
       AddProbableKeyEvent('m', 0.0025, v);
       AddProbableKeyEvent('j', 0.0025, v);
       AddProbableKeyEvent('k', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["o"];
       AddProbableKeyEvent('o', 0.99, v);
       AddProbableKeyEvent('i', 0.0025, v);
       AddProbableKeyEvent('k', 0.0025, v);
       AddProbableKeyEvent('l', 0.0025, v);
       AddProbableKeyEvent('p', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["p"];
       AddProbableKeyEvent('p', 0.99, v);
       AddProbableKeyEvent('o', 0.003, v);
       AddProbableKeyEvent('l', 0.003, v);
       AddProbableKeyEvent('-', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["q"];
       AddProbableKeyEvent('q', 0.99, v);
       AddProbableKeyEvent('w', 0.003, v);
       AddProbableKeyEvent('a', 0.003, v);
       AddProbableKeyEvent('s', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["r"];
       AddProbableKeyEvent('r', 0.99, v);
       AddProbableKeyEvent('t', 0.003, v);
       AddProbableKeyEvent('f', 0.003, v);
       AddProbableKeyEvent('e', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["s"];
       AddProbableKeyEvent('s', 0.99, v);
       AddProbableKeyEvent('a', 0.0025, v);
       AddProbableKeyEvent('d', 0.0025, v);
       AddProbableKeyEvent('w', 0.0025, v);
       AddProbableKeyEvent('z', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["t"];
       AddProbableKeyEvent('t', 0.99, v);
       AddProbableKeyEvent('r', 0.003, v);
       AddProbableKeyEvent('y', 0.003, v);
       AddProbableKeyEvent('g', 0.003, v);
     }
     {
       ProbableKeyEvents *v = &table_["u"];
       AddProbableKeyEvent('u', 0.99, v);
       AddProbableKeyEvent('y', 0.003, v);
       AddProbableKeyEvent('i', 0.003, v);
       AddProbableKeyEvent('j', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["v"];
       AddProbableKeyEvent('v', 0.99, v);
       AddProbableKeyEvent('c', 0.0025, v);
       AddProbableKeyEvent('g', 0.0025, v);
       AddProbableKeyEvent('h', 0.0025, v);
       AddProbableKeyEvent('b', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["w"];
       AddProbableKeyEvent('w', 0.99, v);
       AddProbableKeyEvent('q', 0.0025, v);
       AddProbableKeyEvent('e', 0.0025, v);
       AddProbableKeyEvent('a', 0.0025, v);
       AddProbableKeyEvent('s', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["x"];
       AddProbableKeyEvent('x', 0.99, v);
       AddProbableKeyEvent('z', 0.0025, v);
       AddProbableKeyEvent('d', 0.0025, v);
       AddProbableKeyEvent('f', 0.0025, v);
       AddProbableKeyEvent('c', 0.0025, v);
     }
     {
       ProbableKeyEvents *v = &table_["y"];
       AddProbableKeyEvent('y', 0.99, v);
       AddProbableKeyEvent('t', 0.003, v);
       AddProbableKeyEvent('h', 0.003, v);
       AddProbableKeyEvent('u', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["z"];
       AddProbableKeyEvent('z', 0.99, v);
       AddProbableKeyEvent('s', 0.003, v);
       AddProbableKeyEvent('d', 0.003, v);
       AddProbableKeyEvent('x', 0.004, v);
     }
     {
       ProbableKeyEvents *v = &table_["-"];
       AddProbableKeyEvent('-', 0.99, v);
       AddProbableKeyEvent('p', 0.003, v);
       AddProbableKeyEvent('o', 0.003, v);
       AddProbableKeyEvent('l', 0.004, v);
     }
   }

   void InsertCharacter(TypingCorrector *corrector,
                        const StringPiece& key) const {
     corrector->InsertCharacter(key, table_.find(key)->second);
   }

  private:
   CorrectionTable table_;

   void AddProbableKeyEvent(int key_code, double probability,
                            ProbableKeyEvents *probable_key_events) {
     ProbableKeyEvent *event = probable_key_events->Add();
     event->set_key_code(key_code);
     event->set_probability(probability);
   }

   DISALLOW_COPY_AND_ASSIGN(CostTableForTest);
 };

 class TypingCorrectorTest : public ::testing::Test {
  protected:
   TypingCorrectorTest() :
       qwerty_typing_model_(
           kKeyCharacters_QwertyMobileHiragana,
           kKeyCharactersSize_QwertyMobileHiragana,
           kCostTable_QwertyMobileHiragana,
           kCostTableSize_QwertyMobileHiragana,
           kCostMappingTable_QwertyMobileHiragana) {
   }

   virtual void SetUp() {
     ConfigHandler::GetConfig(&config_backup_);
     Config config;
     ConfigHandler::GetDefaultConfig(&config);
     config.set_use_typing_correction(true);
     ConfigHandler::SetConfig(config);
     commands::Request request;
     request.set_special_romanji_table(
         commands::Request::QWERTY_MOBILE_TO_HIRAGANA);
     qwerty_table_.InitializeWithRequestAndConfig(request, config);
     qwerty_table_.typing_model_ = &qwerty_typing_model_;
   }

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

   void InsertOneByOne(const char *keys, TypingCorrector *corrector) {
     for (const char *key = keys; *key != '\0'; ++key) {
       Singleton<CostTableForTest>::get()->InsertCharacter(corrector,
                                                           StringPiece(key, 1));
     }
   }

   bool FindKey(const vector<TypeCorrectedQuery> &queries,
                const string &key) {
     for (size_t i = 0; i < queries.size(); ++i) {
       const set<string> &expanded = queries[i].expanded;
       if (expanded.empty() && queries[i].base == key) {
         return true;
       }
       for (set<string>::const_iterator itr = expanded.begin();
            itr != expanded.end(); ++itr) {
         if (queries[i].base + *itr == key) {
           return true;
         }
       }
     }
     return false;
   }

   void ExpectTypingCorrectorEqual(const TypingCorrector &l,
                                   const TypingCorrector &r) {
     EXPECT_EQ(l.available_, r.available_);
     EXPECT_EQ(l.table_, r.table_);
     EXPECT_EQ(l.max_correction_query_candidates_,
               r.max_correction_query_candidates_);
     EXPECT_EQ(l.max_correction_query_results_,
               r.max_correction_query_results_);
     EXPECT_EQ(l.top_n_.size(), r.top_n_.size());
     for (size_t i = 0; i < l.top_n_.size(); ++i) {
       EXPECT_EQ(l.top_n_[i], l.top_n_[i]);
     }
   }

   Config config_backup_;
   Table qwerty_table_;
   TypingModel qwerty_typing_model_;
 };

 TEST_F(TypingCorrectorTest, TypingCorrection) {
   const int kCorrectedQueryCandidates = 1000;
   const int kCorrectedQueryResults = 1000;
   TypingCorrector corrector(&qwerty_table_,
                             kCorrectedQueryCandidates,
                             kCorrectedQueryResults);
   ASSERT_TRUE(corrector.IsAvailable());

   struct {
     const char *keys;
     const char *correction;
     const char *exact_composition;
   } kTestCases[] = {
     // "phayou" -> "おはよう", "ｐはよう"
     { "phayou",
       "\xE3\x81\x8A\xE3\x81\xAF\xE3\x82\x88\xE3\x81\x86",
       "\xEF\xBD\x90\xE3\x81\xAF\xE3\x82\x88\xE3\x81\x86"},
     // "orukaresama" -> "おつかれさま", "おるかれさま"
     { "orukaresama",
       "\xE3\x81\x8A\xE3\x81\xA4\xE3\x81\x8B"
           "\xE3\x82\x8C\xE3\x81\x95\xE3\x81\xBE",
       "\xE3\x81\x8A\xE3\x82\x8B\xE3\x81\x8B"
           "\xE3\x82\x8C\xE3\x81\x95\xE3\x81\xBE"},
     // "gu-huru" -> "ぐーぐる", "ぐーふる"
     { "gu-huru",
       "\xE3\x81\x90\xE3\x83\xBC\xE3\x81\x90\xE3\x82\x8B",
       "\xE3\x81\x90\xE3\x83\xBC\xE3\x81\xB5\xE3\x82\x8B"},
     // "bihongo" -> "にほんご", "びほんご"
     { "bihongo",
       "\xE3\x81\xAB\xE3\x81\xBB\xE3\x82\x93\xE3\x81\x94",
       "\xE3\x81\xB3\xE3\x81\xBB\xE3\x82\x93\xE3\x81\x94"},
     // "yajiniku" -> "やきにく", "やじにく"
     { "yajiniku",
       "\xE3\x82\x84\xE3\x81\x8D\xE3\x81\xAB\xE3\x81\x8F",
       "\xE3\x82\x84\xE3\x81\x98\xE3\x81\xAB\xE3\x81\x8F"},
     // "so-natsu" -> "どーなつ", "そーなつ"
     { "so-natsu",
       "\xE3\x81\xA9\xE3\x83\xBC\xE3\x81\xAA\xE3\x81\xA4",
       "\xE3\x81\x9D\xE3\x83\xBC\xE3\x81\xAA\xE3\x81\xA4"},
     // "ohayou" -> NULL, "おはよう"
     // "おはよう" can be generated from raw key so
     // it shouldn't be in correction candidates.
     { "ohayou",
       NULL,
       "\xE3\x81\x8A\xE3\x81\xAF\xE3\x82\x88\xE3\x81\x86"},
     // "syamoji" -> NULL, "しゃもじ"
     // A query which can be composed from raw input
     // shouldn't be in correction candidates.
     // This is more complex pattern than "おはよう" test case.
     // "おはよう" case can be processed correctly by comparing
     // raw input and corrected query.
     // But this case "syamoji" (raw input) and "shamoji" (corrected input)
     // are different but their query is identical ("しゃもじ").
     // Thus we have to also check not only raw/corrected input but also
     // raw/corrected queries.
     { "syamozi",
       NULL,
       "\xE3\x81\x97\xE3\x82\x83\xE3\x82\x82\xE3\x81\x98"},
     // "kaish" -> NULL, "かいしゃ"
     // Pending input is expanded into possible queries for
     // kana-modifier-insensitive-conversion (a.k.a かつこう変換).
     // In this case "kaish" is expanded into "かいしゃ", "かいしゅ"
     // and so on.
     // Typing corrected input "kaisy" is also expanded into
     // "かいしゃ", "かいしゅ" and so on but they are duplicate
     // of expanded queries from "kaish".
     // Thus they shouldn't be in corrected candidates.
     { "kaish",
       NULL,
       "\xE3\x81\x8B\xE3\x81\x84\xE3\x81\x97\xE3\x82\x83"},
   };

   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     SCOPED_TRACE(string("key: ") + kTestCases[i].keys);
     InsertOneByOne(kTestCases[i].keys, &corrector);
     vector<TypeCorrectedQuery> queries;
     corrector.GetQueriesForPrediction(&queries);
     // Number of queries can be equal to kCorrectedQueries.
     EXPECT_GE(kCorrectedQueryResults, queries.size());
     for (vector<TypeCorrectedQuery>::iterator it = queries.begin();
          it != queries.end();
          ++it) {
       // Empty TypeCorrectedQuery is unexpected.
       EXPECT_FALSE(it->base.empty() && it->expanded.empty());
     }
     if (kTestCases[i].correction) {
       EXPECT_TRUE(FindKey(queries, kTestCases[i].correction))
           << kTestCases[i].correction << " isn't contained";
     }
     EXPECT_FALSE(FindKey(queries, kTestCases[i].exact_composition))
         << kTestCases[i].exact_composition << " is contained unexpectedly";
     corrector.Reset();
   }
 }

 TEST_F(TypingCorrectorTest, Invalidate) {
   const CostTableForTest *table = Singleton<CostTableForTest>::get();

   TypingCorrector corrector(&qwerty_table_, 30, 30);

   EXPECT_TRUE(corrector.IsAvailable());
   table->InsertCharacter(&corrector, "p");
   table->InsertCharacter(&corrector, "h");
   table->InsertCharacter(&corrector, "a");

   corrector.Invalidate();
   EXPECT_FALSE(corrector.IsAvailable());

   table->InsertCharacter(&corrector, "y");
   table->InsertCharacter(&corrector, "o");
   table->InsertCharacter(&corrector, "u");

   vector<TypeCorrectedQuery> queries;
   corrector.GetQueriesForPrediction(&queries);
   EXPECT_TRUE(queries.empty());
 }

 TEST_F(TypingCorrectorTest, CopyFrom) {
   TypingCorrector corrector(&qwerty_table_, 30, 30);
   InsertOneByOne("phayou", &corrector);

   TypingCorrector corrector2(NULL, 1000, 1000);
   corrector2.CopyFrom(corrector);

   ExpectTypingCorrectorEqual(corrector, corrector2);
 }

 }  // namespace composer
 }  // namespace mozc
	// 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/internal/typing_corrector.h"

	#include <string>
	#include <vector>
	#include "base/singleton.h"
	#include "config/config_handler.h"
	#include "composer/table.h"
	#include "composer/type_corrected_query.h"
	#include "composer/internal/typing_model.h"
	#include "session/commands.pb.h"
	#include "testing/base/public/gunit.h"

	namespace mozc {
	namespace composer {

	namespace {
	#include "composer/internal/typing_model_qwerty_mobile-hiragana.h"
	}

	using mozc::config::Config;
	using mozc::config::ConfigHandler;

	// Embedded cost for testing purpose.
	class CostTableForTest {
	public:
	typedef map<StringPiece, ProbableKeyEvents> CorrectionTable;

	CostTableForTest() {
	{
	ProbableKeyEvents *v = &table_["a"];
	AddProbableKeyEvent('a', 0.99, v);
	AddProbableKeyEvent('q', 0.003, v);
	AddProbableKeyEvent('w', 0.003, v);
	AddProbableKeyEvent('s', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["b"];
	AddProbableKeyEvent('b', 0.99, v);
	AddProbableKeyEvent('v', 0.0025, v);
	AddProbableKeyEvent('h', 0.0025, v);
	AddProbableKeyEvent('j', 0.0025, v);
	AddProbableKeyEvent('n', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["c"];
	AddProbableKeyEvent('c', 0.99, v);
	AddProbableKeyEvent('x', 0.0025, v);
	AddProbableKeyEvent('f', 0.0025, v);
	AddProbableKeyEvent('g', 0.0025, v);
	AddProbableKeyEvent('v', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["d"];
	AddProbableKeyEvent('d', 0.99, v);
	AddProbableKeyEvent('s', 0.002, v);
	AddProbableKeyEvent('e', 0.002, v);
	AddProbableKeyEvent('f', 0.002, v);
	AddProbableKeyEvent('x', 0.002, v);
	AddProbableKeyEvent('z', 0.002, v);
	}
	{
	ProbableKeyEvents *v = &table_["e"];
	AddProbableKeyEvent('e', 0.99, v);
	AddProbableKeyEvent('w', 0.003, v);
	AddProbableKeyEvent('d', 0.003, v);
	AddProbableKeyEvent('r', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["f"];
	AddProbableKeyEvent('f', 0.99, v);
	AddProbableKeyEvent('d', 0.002, v);
	AddProbableKeyEvent('r', 0.002, v);
	AddProbableKeyEvent('g', 0.002, v);
	AddProbableKeyEvent('c', 0.002, v);
	AddProbableKeyEvent('x', 0.002, v);
	}
	{
	ProbableKeyEvents *v = &table_["g"];
	AddProbableKeyEvent('g', 0.99, v);
	AddProbableKeyEvent('f', 0.002, v);
	AddProbableKeyEvent('t', 0.002, v);
	AddProbableKeyEvent('h', 0.002, v);
	AddProbableKeyEvent('v', 0.002, v);
	AddProbableKeyEvent('c', 0.002, v);
	}
	{
	ProbableKeyEvents *v = &table_["h"];
	AddProbableKeyEvent('h', 0.99, v);
	AddProbableKeyEvent('g', 0.002, v);
	AddProbableKeyEvent('y', 0.002, v);
	AddProbableKeyEvent('j', 0.002, v);
	AddProbableKeyEvent('b', 0.002, v);
	AddProbableKeyEvent('v', 0.002, v);
	}
	{
	ProbableKeyEvents *v = &table_["i"];
	AddProbableKeyEvent('i', 0.99, v);
	AddProbableKeyEvent('u', 0.003, v);
	AddProbableKeyEvent('k', 0.003, v);
	AddProbableKeyEvent('o', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["j"];
	AddProbableKeyEvent('j', 0.99, v);
	AddProbableKeyEvent('h', 0.002, v);
	AddProbableKeyEvent('k', 0.002, v);
	AddProbableKeyEvent('u', 0.002, v);
	AddProbableKeyEvent('n', 0.002, v);
	AddProbableKeyEvent('b', 0.002, v);
	}
	{
	ProbableKeyEvents *v = &table_["k"];
	AddProbableKeyEvent('k', 0.99, v);
	AddProbableKeyEvent('j', 0.002, v);
	AddProbableKeyEvent('i', 0.002, v);
	AddProbableKeyEvent('l', 0.002, v);
	AddProbableKeyEvent('m', 0.002, v);
	AddProbableKeyEvent('n', 0.002, v);
	}
	{
	ProbableKeyEvents *v = &table_["l"];
	AddProbableKeyEvent('l', 0.99, v);
	AddProbableKeyEvent('k', 0.0025, v);
	AddProbableKeyEvent('-', 0.0025, v);
	AddProbableKeyEvent('p', 0.0025, v);
	AddProbableKeyEvent('o', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["m"];
	AddProbableKeyEvent('m', 0.99, v);
	AddProbableKeyEvent('n', 0.003, v);
	AddProbableKeyEvent('k', 0.003, v);
	AddProbableKeyEvent('l', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["n"];
	AddProbableKeyEvent('n', 0.99, v);
	AddProbableKeyEvent('b', 0.0025, v);
	AddProbableKeyEvent('m', 0.0025, v);
	AddProbableKeyEvent('j', 0.0025, v);
	AddProbableKeyEvent('k', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["o"];
	AddProbableKeyEvent('o', 0.99, v);
	AddProbableKeyEvent('i', 0.0025, v);
	AddProbableKeyEvent('k', 0.0025, v);
	AddProbableKeyEvent('l', 0.0025, v);
	AddProbableKeyEvent('p', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["p"];
	AddProbableKeyEvent('p', 0.99, v);
	AddProbableKeyEvent('o', 0.003, v);
	AddProbableKeyEvent('l', 0.003, v);
	AddProbableKeyEvent('-', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["q"];
	AddProbableKeyEvent('q', 0.99, v);
	AddProbableKeyEvent('w', 0.003, v);
	AddProbableKeyEvent('a', 0.003, v);
	AddProbableKeyEvent('s', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["r"];
	AddProbableKeyEvent('r', 0.99, v);
	AddProbableKeyEvent('t', 0.003, v);
	AddProbableKeyEvent('f', 0.003, v);
	AddProbableKeyEvent('e', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["s"];
	AddProbableKeyEvent('s', 0.99, v);
	AddProbableKeyEvent('a', 0.0025, v);
	AddProbableKeyEvent('d', 0.0025, v);
	AddProbableKeyEvent('w', 0.0025, v);
	AddProbableKeyEvent('z', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["t"];
	AddProbableKeyEvent('t', 0.99, v);
	AddProbableKeyEvent('r', 0.003, v);
	AddProbableKeyEvent('y', 0.003, v);
	AddProbableKeyEvent('g', 0.003, v);
	}
	{
	ProbableKeyEvents *v = &table_["u"];
	AddProbableKeyEvent('u', 0.99, v);
	AddProbableKeyEvent('y', 0.003, v);
	AddProbableKeyEvent('i', 0.003, v);
	AddProbableKeyEvent('j', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["v"];
	AddProbableKeyEvent('v', 0.99, v);
	AddProbableKeyEvent('c', 0.0025, v);
	AddProbableKeyEvent('g', 0.0025, v);
	AddProbableKeyEvent('h', 0.0025, v);
	AddProbableKeyEvent('b', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["w"];
	AddProbableKeyEvent('w', 0.99, v);
	AddProbableKeyEvent('q', 0.0025, v);
	AddProbableKeyEvent('e', 0.0025, v);
	AddProbableKeyEvent('a', 0.0025, v);
	AddProbableKeyEvent('s', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["x"];
	AddProbableKeyEvent('x', 0.99, v);
	AddProbableKeyEvent('z', 0.0025, v);
	AddProbableKeyEvent('d', 0.0025, v);
	AddProbableKeyEvent('f', 0.0025, v);
	AddProbableKeyEvent('c', 0.0025, v);
	}
	{
	ProbableKeyEvents *v = &table_["y"];
	AddProbableKeyEvent('y', 0.99, v);
	AddProbableKeyEvent('t', 0.003, v);
	AddProbableKeyEvent('h', 0.003, v);
	AddProbableKeyEvent('u', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["z"];
	AddProbableKeyEvent('z', 0.99, v);
	AddProbableKeyEvent('s', 0.003, v);
	AddProbableKeyEvent('d', 0.003, v);
	AddProbableKeyEvent('x', 0.004, v);
	}
	{
	ProbableKeyEvents *v = &table_["-"];
	AddProbableKeyEvent('-', 0.99, v);
	AddProbableKeyEvent('p', 0.003, v);
	AddProbableKeyEvent('o', 0.003, v);
	AddProbableKeyEvent('l', 0.004, v);
	}
	}

	void InsertCharacter(TypingCorrector *corrector,
	const StringPiece& key) const {
	corrector->InsertCharacter(key, table_.find(key)->second);
	}

	private:
	CorrectionTable table_;

	void AddProbableKeyEvent(int key_code, double probability,
	ProbableKeyEvents *probable_key_events) {
	ProbableKeyEvent *event = probable_key_events->Add();
	event->set_key_code(key_code);
	event->set_probability(probability);
	}

	DISALLOW_COPY_AND_ASSIGN(CostTableForTest);
	};

	class TypingCorrectorTest : public ::testing::Test {
	protected:
	TypingCorrectorTest() :
	qwerty_typing_model_(
	kKeyCharacters_QwertyMobileHiragana,
	kKeyCharactersSize_QwertyMobileHiragana,
	kCostTable_QwertyMobileHiragana,
	kCostTableSize_QwertyMobileHiragana,
	kCostMappingTable_QwertyMobileHiragana) {
	}

	virtual void SetUp() {
	ConfigHandler::GetConfig(&config_backup_);
	Config config;
	ConfigHandler::GetDefaultConfig(&config);
	config.set_use_typing_correction(true);
	ConfigHandler::SetConfig(config);
	commands::Request request;
	request.set_special_romanji_table(
	commands::Request::QWERTY_MOBILE_TO_HIRAGANA);
	qwerty_table_.InitializeWithRequestAndConfig(request, config);
	qwerty_table_.typing_model_ = &qwerty_typing_model_;
	}

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

	void InsertOneByOne(const char keys, TypingCorrector corrector) {
	for (const char key = keys; key != '\0'; ++key) {
	Singleton<CostTableForTest>::get()->InsertCharacter(corrector,
	StringPiece(key, 1));
	}
	}

	bool FindKey(const vector<TypeCorrectedQuery> &queries,
	const string &key) {
	for (size_t i = 0; i < queries.size(); ++i) {
	const set<string> &expanded = queries[i].expanded;
	if (expanded.empty() && queries[i].base == key) {
	return true;
	}
	for (set<string>::const_iterator itr = expanded.begin();
	itr != expanded.end(); ++itr) {
	if (queries[i].base + *itr == key) {
	return true;
	}
	}
	}
	return false;
	}

	void ExpectTypingCorrectorEqual(const TypingCorrector &l,
	const TypingCorrector &r) {
	EXPECT_EQ(l.available_, r.available_);
	EXPECT_EQ(l.table_, r.table_);
	EXPECT_EQ(l.max_correction_query_candidates_,
	r.max_correction_query_candidates_);
	EXPECT_EQ(l.max_correction_query_results_,
	r.max_correction_query_results_);
	EXPECT_EQ(l.top_n_.size(), r.top_n_.size());
	for (size_t i = 0; i < l.top_n_.size(); ++i) {
	EXPECT_EQ(l.top_n_[i], l.top_n_[i]);
	}
	}

	Config config_backup_;
	Table qwerty_table_;
	TypingModel qwerty_typing_model_;
	};

	TEST_F(TypingCorrectorTest, TypingCorrection) {
	const int kCorrectedQueryCandidates = 1000;
	const int kCorrectedQueryResults = 1000;
	TypingCorrector corrector(&qwerty_table_,
	kCorrectedQueryCandidates,
	kCorrectedQueryResults);
	ASSERT_TRUE(corrector.IsAvailable());

	struct {
	const char *keys;
	const char *correction;
	const char *exact_composition;
	} kTestCases[] = {
	// "phayou" -> "おはよう", "ｐはよう"
	{ "phayou",
	"\xE3\x81\x8A\xE3\x81\xAF\xE3\x82\x88\xE3\x81\x86",
	"\xEF\xBD\x90\xE3\x81\xAF\xE3\x82\x88\xE3\x81\x86"},
	// "orukaresama" -> "おつかれさま", "おるかれさま"
	{ "orukaresama",
	"\xE3\x81\x8A\xE3\x81\xA4\xE3\x81\x8B"
	"\xE3\x82\x8C\xE3\x81\x95\xE3\x81\xBE",
	"\xE3\x81\x8A\xE3\x82\x8B\xE3\x81\x8B"
	"\xE3\x82\x8C\xE3\x81\x95\xE3\x81\xBE"},
	// "gu-huru" -> "ぐーぐる", "ぐーふる"
	{ "gu-huru",
	"\xE3\x81\x90\xE3\x83\xBC\xE3\x81\x90\xE3\x82\x8B",
	"\xE3\x81\x90\xE3\x83\xBC\xE3\x81\xB5\xE3\x82\x8B"},
	// "bihongo" -> "にほんご", "びほんご"
	{ "bihongo",
	"\xE3\x81\xAB\xE3\x81\xBB\xE3\x82\x93\xE3\x81\x94",
	"\xE3\x81\xB3\xE3\x81\xBB\xE3\x82\x93\xE3\x81\x94"},
	// "yajiniku" -> "やきにく", "やじにく"
	{ "yajiniku",
	"\xE3\x82\x84\xE3\x81\x8D\xE3\x81\xAB\xE3\x81\x8F",
	"\xE3\x82\x84\xE3\x81\x98\xE3\x81\xAB\xE3\x81\x8F"},
	// "so-natsu" -> "どーなつ", "そーなつ"
	{ "so-natsu",
	"\xE3\x81\xA9\xE3\x83\xBC\xE3\x81\xAA\xE3\x81\xA4",
	"\xE3\x81\x9D\xE3\x83\xBC\xE3\x81\xAA\xE3\x81\xA4"},
	// "ohayou" -> NULL, "おはよう"
	// "おはよう" can be generated from raw key so
	// it shouldn't be in correction candidates.
	{ "ohayou",
	NULL,
	"\xE3\x81\x8A\xE3\x81\xAF\xE3\x82\x88\xE3\x81\x86"},
	// "syamoji" -> NULL, "しゃもじ"
	// A query which can be composed from raw input
	// shouldn't be in correction candidates.
	// This is more complex pattern than "おはよう" test case.
	// "おはよう" case can be processed correctly by comparing
	// raw input and corrected query.
	// But this case "syamoji" (raw input) and "shamoji" (corrected input)
	// are different but their query is identical ("しゃもじ").
	// Thus we have to also check not only raw/corrected input but also
	// raw/corrected queries.
	{ "syamozi",
	NULL,
	"\xE3\x81\x97\xE3\x82\x83\xE3\x82\x82\xE3\x81\x98"},
	// "kaish" -> NULL, "かいしゃ"
	// Pending input is expanded into possible queries for
	// kana-modifier-insensitive-conversion (a.k.a かつこう変換).
	// In this case "kaish" is expanded into "かいしゃ", "かいしゅ"
	// and so on.
	// Typing corrected input "kaisy" is also expanded into
	// "かいしゃ", "かいしゅ" and so on but they are duplicate
	// of expanded queries from "kaish".
	// Thus they shouldn't be in corrected candidates.
	{ "kaish",
	NULL,
	"\xE3\x81\x8B\xE3\x81\x84\xE3\x81\x97\xE3\x82\x83"},
	};

	for (size_t i = 0; i < arraysize(kTestCases); ++i) {
	SCOPED_TRACE(string("key: ") + kTestCases[i].keys);
	InsertOneByOne(kTestCases[i].keys, &corrector);
	vector<TypeCorrectedQuery> queries;
	corrector.GetQueriesForPrediction(&queries);
	// Number of queries can be equal to kCorrectedQueries.
	EXPECT_GE(kCorrectedQueryResults, queries.size());
	for (vector<TypeCorrectedQuery>::iterator it = queries.begin();
	it != queries.end();
	++it) {
	// Empty TypeCorrectedQuery is unexpected.
	EXPECT_FALSE(it->base.empty() && it->expanded.empty());
	}
	if (kTestCases[i].correction) {
	EXPECT_TRUE(FindKey(queries, kTestCases[i].correction))
	<< kTestCases[i].correction << " isn't contained";
	}
	EXPECT_FALSE(FindKey(queries, kTestCases[i].exact_composition))
	<< kTestCases[i].exact_composition << " is contained unexpectedly";
	corrector.Reset();
	}
	}

	TEST_F(TypingCorrectorTest, Invalidate) {
	const CostTableForTest *table = Singleton<CostTableForTest>::get();

	TypingCorrector corrector(&qwerty_table_, 30, 30);

	EXPECT_TRUE(corrector.IsAvailable());
	table->InsertCharacter(&corrector, "p");
	table->InsertCharacter(&corrector, "h");
	table->InsertCharacter(&corrector, "a");

	corrector.Invalidate();
	EXPECT_FALSE(corrector.IsAvailable());

	table->InsertCharacter(&corrector, "y");
	table->InsertCharacter(&corrector, "o");
	table->InsertCharacter(&corrector, "u");

	vector<TypeCorrectedQuery> queries;
	corrector.GetQueriesForPrediction(&queries);
	EXPECT_TRUE(queries.empty());
	}

	TEST_F(TypingCorrectorTest, CopyFrom) {
	TypingCorrector corrector(&qwerty_table_, 30, 30);
	InsertOneByOne("phayou", &corrector);

	TypingCorrector corrector2(NULL, 1000, 1000);
	corrector2.CopyFrom(corrector);

	ExpectTypingCorrectorEqual(corrector, corrector2);
	}

	} // namespace composer
	} // namespace mozc