// 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 "rewriter/date_rewriter.h"

#include <cstddef>

#include "base/clock_mock.h"
#include "base/port.h"
#include "base/scoped_ptr.h"
#include "base/system_util.h"
#include "base/util.h"
#include "composer/composer.h"
#include "composer/table.h"
#include "config/config_handler.h"
#include "config/config.pb.h"
#include "converter/conversion_request.h"
#include "converter/segments.h"
#include "session/commands.pb.h"
#include "testing/base/public/gunit.h"

DECLARE_string(test_tmpdir);

namespace mozc {
namespace {

void Expect2Results(const vector<string> &src,
                    const string &exp1,
                    const string &exp2) {
  EXPECT_EQ(2, src.size());
  EXPECT_NE(src[0], src[1]);
  for (int i = 0; i < 2; ++i) {
    EXPECT_TRUE(src[i] == exp1 || src[i] == exp2);
  }
}

void Expect3Results(const vector<string> &src,
                    const string &exp1,
                    const string &exp2,
                    const string &exp3) {
  EXPECT_EQ(3, src.size());
  EXPECT_NE(src[0], src[1]);
  EXPECT_NE(src[1], src[2]);
  EXPECT_NE(src[2], src[0]);
  for (int i = 0; i < 3; ++i) {
    EXPECT_TRUE(src[i] == exp1 || src[i] == exp2 || src[i] == exp3);
  }
}

void Expect4Results(const vector<string> &src,
                    const string &exp1,
                    const string &exp2,
                    const string &exp3,
                    const string &exp4) {
  EXPECT_EQ(4, src.size());
  EXPECT_NE(src[0], src[1]);
  EXPECT_NE(src[0], src[2]);
  EXPECT_NE(src[0], src[3]);
  EXPECT_NE(src[1], src[2]);
  EXPECT_NE(src[1], src[3]);
  EXPECT_NE(src[2], src[3]);
  for (int i = 0; i < 4; ++i) {
    EXPECT_TRUE(src[i] == exp1 || src[i] == exp2 ||
                src[i] == exp3 || src[i] == exp4);
  }
}

void Expect5Results(const vector<string> &src,
                    const string &exp1,
                    const string &exp2,
                    const string &exp3,
                    const string &exp4,
                    const string &exp5) {
  EXPECT_EQ(5, src.size());
  EXPECT_NE(src[0], src[1]);
  EXPECT_NE(src[0], src[2]);
  EXPECT_NE(src[0], src[3]);
  EXPECT_NE(src[0], src[4]);
  EXPECT_NE(src[1], src[2]);
  EXPECT_NE(src[1], src[3]);
  EXPECT_NE(src[1], src[4]);
  EXPECT_NE(src[2], src[3]);
  EXPECT_NE(src[2], src[4]);
  EXPECT_NE(src[3], src[4]);
  for (int i = 0; i < 5; ++i) {
    EXPECT_TRUE(src[i] == exp1 || src[i] == exp2 ||
                src[i] == exp3 || src[i] == exp4 || src[i] == exp5);
  }
}

void InitCandidate(const string &key, const string &value,
                   Segment::Candidate *candidate) {
  candidate->content_key = key;
  candidate->value = value;
  candidate->content_value = value;
}

void AppendSegment(const string &key, const string &value,
                   Segments *segments) {
  Segment *seg = segments->add_segment();
  seg->set_key(key);
  InitCandidate(key, value, seg->add_candidate());
}

void InitSegment(const string &key, const string &value,
                 Segments *segments) {
  segments->Clear();
  AppendSegment(key, value, segments);
}

void InitMetaSegment(const string &key, const string &value,
                     Segments *segments) {
  segments->Clear();
  Segment *seg = segments->add_segment();
  seg->set_key(key);
  InitCandidate(key, value, seg->add_meta_candidate());
}

void InsertCandidate(const string &key,
                const string &value,
                const int position,
                Segment *segment) {
  Segment::Candidate *cand = segment->insert_candidate(position);
  cand->content_key = key;
  cand->value = value;
  cand->content_value = value;
}

int CountDescription(const Segments &segments, const string &description) {
  int num = 0;
  for (size_t i = 0; i < segments.segment(0).candidates_size(); ++i) {
    if (segments.segment(0).candidate(i).description == description) {
        ++num;
     }
  }
  return num;
}

bool ContainCandidate(const Segments &segments, const string &candidate) {
  const Segment &segment = segments.segment(0);

  for (size_t i = 0; i < segment.candidates_size(); ++i) {
    if (candidate == segment.candidate(i).value) {
      return true;
    }
  }
  return false;
}

string GetNthCandidateValue(const Segments &segments, const int n) {
  const Segment &segment = segments.segment(0);
  return segment.candidate(n).value;
}

bool IsStringContained(const string &key, const vector<string> &container) {
  for (size_t i = 0; i < container.size(); ++i) {
    if (key == container[i]) {
      return true;
    }
  }
  return false;
}

bool AllElementsAreSame(const string &key, const vector<string> &container) {
  for (size_t i = 0; i < container.size(); ++i) {
    if (key != container[i]) {
      return false;
    }
  }
  return true;
}

// "2011-04-18 15:06:31 (Mon)" UTC
const uint64 kTestSeconds =  1303139191uLL;
// micro seconds. it is random value.
const uint32 kTestMicroSeconds = 588377u;

}  // namespace

class DateRewriterTest : public testing::Test {
 protected:
  virtual void SetUp() {
    SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir);
    config::Config default_config;
    config::ConfigHandler::GetDefaultConfig(&default_config);
    config::ConfigHandler::SetConfig(default_config);
  }

  virtual void TearDown() {
    config::Config default_config;
    config::ConfigHandler::GetDefaultConfig(&default_config);
    config::ConfigHandler::SetConfig(default_config);
  }
};

TEST_F(DateRewriterTest, DateRewriteTest) {
  scoped_ptr<ClockMock> mock_clock(
      new ClockMock(kTestSeconds, kTestMicroSeconds));
  Util::SetClockHandler(mock_clock.get());

  DateRewriter rewriter;
  Segments segments;
  const ConversionRequest request;

  // "きょう/今日/今日の日付"
  {
    InitSegment("\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86",
                "\xE4\xBB\x8A\xE6\x97\xA5", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(5, CountDescription(
        segments,
        "\xE4\xBB\x8A\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));

    // "平成23年4月18日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE5\xB9\xB3\xE6\x88\x90" "23" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "18" "\xE6\x97\xA5"));
    // "2011年4月18日"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "18" "\xE6\x97\xA5"));
    // "2011-04-18"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011-04-18"));
    // "2011/04/18"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011/04/18"));
    // "月曜日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE6\x9C\x88" "\xE6\x9B\x9C\xE6\x97\xA5"));
  }

  // "あした/明日/明日の日付"
  {
    InitSegment("\xE3\x81\x82\xE3\x81\x97\xE3\x81\x9F",
                "\xE6\x98\x8E\xE6\x97\xA5", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(5, CountDescription(
        segments,
        "\xE6\x98\x8E\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));

    // "平成23年4月19日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE5\xB9\xB3\xE6\x88\x90" "23" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "19" "\xE6\x97\xA5"));
    // "2011年4月19日"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "19" "\xE6\x97\xA5"));
    // "2011-04-19"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011-04-19"));
    // "2011/04/19"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011/04/19"));
    // "火曜日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE7\x81\xAB" "\xE6\x9B\x9C\xE6\x97\xA5"));
  }

  // "きのう/昨日/昨日の日付"
  {
    InitSegment("\xE3\x81\x8D\xE3\x81\xAE\xE3\x81\x86",
                "\xE6\x98\xA8\xE6\x97\xA5", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(5, CountDescription(
        segments,
        "\xE6\x98\xA8\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));

    // "平成23年4月17日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE5\xB9\xB3\xE6\x88\x90" "23" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "17" "\xE6\x97\xA5"));
    // "2011年4月17日"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "17" "\xE6\x97\xA5"));
    // "2011-04-17"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011-04-17"));
    // "2011/04/17"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011/04/17"));
    // "日曜日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE6\x97\xA5" "\xE6\x9B\x9C\xE6\x97\xA5"));
  }

  // "あさって/明後日/明後日の日付"
  {
    InitSegment("\xE3\x81\x82\xE3\x81\x95\xE3\x81\xA3\xE3\x81\xA6",
                "\xE6\x98\x8E\xE5\xBE\x8C\xE6\x97\xA5", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(5, CountDescription(
        segments,
        "\xE6\x98\x8E\xE5\xBE\x8C\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));

    // "平成23年4月20日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE5\xB9\xB3\xE6\x88\x90" "23" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "20" "\xE6\x97\xA5"));
    // "2011年4月20日"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011" "\xE5\xB9\xB4"
        "4" "\xE6\x9C\x88"
        "20" "\xE6\x97\xA5"));
    // "2011-04-20"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011-04-20"));
    // "2011/04/20"
    EXPECT_TRUE(ContainCandidate(segments,
        "2011/04/20"));
    // "水曜日"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE6\xB0\xB4" "\xE6\x9B\x9C\xE6\x97\xA5"));
  }

  // "にちじ/日時/現在の日時"
  {
    InitSegment("\xE3\x81\xAB\xE3\x81\xA1\xE3\x81\x98",
                "\xE6\x97\xA5\xE6\x99\x82", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(1, CountDescription(
        segments,
        "\xE7\x8F\xBE\xE5\x9C\xA8\xE3\x81\xAE\xE6\x97\xA5\xE6\x99\x82"));

    // "2011/04/18 15:06"
    EXPECT_TRUE(ContainCandidate(segments, "2011/04/18 15:06"));
  }

  // "いま/今/現在の時刻"
  {
    InitSegment("\xE3\x81\x84\xE3\x81\xBE",
                "\xE4\xBB\x8A", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(3, CountDescription(
        segments,
        "\xE7\x8F\xBE\xE5\x9C\xA8\xE3\x81\xAE\xE6\x99\x82\xE5\x88\xBB"));

    // "15:06"
    EXPECT_TRUE(ContainCandidate(segments,
        "15:06"));
    // "15時06分"
    EXPECT_TRUE(ContainCandidate(segments,
        "15" "\xE6\x99\x82" "06" "\xE5\x88\x86"));
    // "午後3時6分"
    EXPECT_TRUE(ContainCandidate(segments,
        "\xE5\x8D\x88\xE5\xBE\x8C" "3" "\xE6\x99\x82" "6" "\xE5\x88\x86"));
  }

  // DateRewrite candidate order check.
  {
    // This parameter is copied from date_rewriter.cc.
    const size_t kMinimumDateCandidateIdx = 3;

    const char* kTodayCandidate[] = {
      "2011/04/18",
      "2011-04-18",
      // "2011年4月18日"
      "2011\xE5\xB9\xB4" "4\xE6\x9C\x88" "18\xE6\x97\xA5",
      // "平成23年4月18日"
      "\xE5\xB9\xB3\xE6\x88\x90" "23\xE5\xB9\xB4"
      "4\xE6\x9C\x88" "18\xE6\x97\xA5",
      // "月曜日"
      "\xE6\x9C\x88\xE6\x9B\x9C\xE6\x97\xA5"};

    // If initial count of candidate is 1, date rewrited candidate start from 1.
    // "きょう", "今日"
    InitSegment("\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86",
                "\xE4\xBB\x8A\xE6\x97\xA5", &segments);
    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    EXPECT_EQ(5, CountDescription(
        segments,
        // "今日の日付"
        "\xE4\xBB\x8A\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));
    size_t offset = 1;
    for (int rel_cand_idx = 0; rel_cand_idx < arraysize(kTodayCandidate);
         ++rel_cand_idx) {
      EXPECT_EQ(kTodayCandidate[rel_cand_idx],
                GetNthCandidateValue(segments, rel_cand_idx + offset));
    }

    // If initial count of candidate is 5 and target candidate is located at
    // index 4, date rewrited candidate start from 5.
    // "きょう", "今日"
    InitSegment("\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86",
                "\xE4\xBB\x8A\xE6\x97\xA5", &segments);

    // Inserts no meaning candidates into segment.
    InsertCandidate("Candidate1", "Candidate1", 0, segments.mutable_segment(0));
    InsertCandidate("Candidate2", "Candidate2", 0, segments.mutable_segment(0));
    InsertCandidate("Candidate3", "Candidate3", 0, segments.mutable_segment(0));
    InsertCandidate("Candidate4", "Candidate4", 0, segments.mutable_segment(0));

    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    // "今日の日付"
    EXPECT_EQ(5, CountDescription(
        segments,
        "\xE4\xBB\x8A\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));

    offset = 5;
    for (int rel_cand_idx = 0; rel_cand_idx < arraysize(kTodayCandidate);
         ++rel_cand_idx) {
      EXPECT_EQ(kTodayCandidate[rel_cand_idx],
                GetNthCandidateValue(segments, rel_cand_idx + offset));
    }

    // If initial count of candidate is 5 and target candidate is located at
    // index 0, date rewrited candidate start from kMinimumDateCandidateIdx.
    // "きょう", "今日"
    InitSegment("\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86",
                "\xE4\xBB\x8A\xE6\x97\xA5", &segments);

    // Inserts no meaning candidates into segment.
    InsertCandidate("Candidate1", "Candidate1", 1, segments.mutable_segment(0));
    InsertCandidate("Candidate2", "Candidate2", 1, segments.mutable_segment(0));
    InsertCandidate("Candidate3", "Candidate3", 1, segments.mutable_segment(0));
    InsertCandidate("Candidate4", "Candidate4", 1, segments.mutable_segment(0));

    EXPECT_TRUE(rewriter.Rewrite(request, &segments));
    // "今日の日付"
    EXPECT_EQ(5, CountDescription(
        segments,
        "\xE4\xBB\x8A\xE6\x97\xA5"
        "\xE3\x81\xAE\xE6\x97\xA5\xE4\xBB\x98"));

    for (int rel_cand_idx = 0; rel_cand_idx < arraysize(kTodayCandidate);
         ++rel_cand_idx) {
      EXPECT_EQ(kTodayCandidate[rel_cand_idx],
                GetNthCandidateValue(segments,
                                     rel_cand_idx + kMinimumDateCandidateIdx));
    }
  }

  Util::SetClockHandler(NULL);
}

TEST_F(DateRewriterTest, ADToERA) {
  DateRewriter rewriter;
  vector<string> results;
  const ConversionRequest request;

  results.clear();
  rewriter.AdToEra(0, &results);
  EXPECT_EQ(results.size(), 0);

  // AD.645 is "大化元(年)"
  results.clear();
  rewriter.AdToEra(645, &results);
  EXPECT_EQ(results.size(), 1);
  EXPECT_EQ(results[0],
            "\xE5\xA4\xA7\xE5\x8C\x96\xE5\x85\x83");

  // AD.646 is "大化2(年)" or "大化二(年)"
  results.clear();
  rewriter.AdToEra(646, &results);
  EXPECT_EQ(results.size(), 2);
  Expect2Results(results,
            "\xE5\xA4\xA7\xE5\x8C\x96" "2",
            "\xE5\xA4\xA7\xE5\x8C\x96\xE4\xBA\x8C");


  // AD.1976 is "昭和51(年)" or "昭和五十一(年)"
  results.clear();
  rewriter.AdToEra(1976, &results);
  EXPECT_EQ(results.size(), 2);
  Expect2Results(results,
            "\xE6\x98\xAD\xE5\x92\x8C" "51",
            "\xE6\x98\xAD\xE5\x92\x8C\xE4\xBA\x94\xE5\x8D\x81\xE4\xB8\x80");

  // AD.1989 is "昭和64(年)" or "昭和六四(年)" or "平成元(年)"
  results.clear();
  rewriter.AdToEra(1989, &results);
  Expect3Results(results,
                 "\xE6\x98\xAD\xE5\x92\x8C" "64",
                 "\xE6\x98\xAD\xE5\x92\x8C\xE5\x85\xAD\xE5\x8D\x81\xE5\x9B\x9B",
                 "\xE5\xB9\xB3\xE6\x88\x90\xE5\x85\x83");

  // AD.1990 is "平成2(年)" or "平成(二)年"
  results.clear();
  rewriter.AdToEra(1990, &results);
  EXPECT_EQ(results.size(), 2);
  Expect2Results(results,
            "\xE5\xB9\xB3\xE6\x88\x90" "2",
            "\xE5\xB9\xB3\xE6\x88\x90\xE4\xBA\x8C");

  // 2 courts era.
  // AD.1331 "元徳3(年)" or "元弘元(年)"
  results.clear();
  rewriter.AdToEra(1331, &results);
  Expect3Results(results,
                 "\xE5\x85\x83\xE5\xBE\xB3" "3",
                 "\xE5\x85\x83\xE5\xBE\xB3\xE4\xB8\x89",
                 "\xE5\x85\x83\xE5\xBC\x98\xE5\x85\x83");

  // AD.1393 "明徳4(年)" or "明徳四(年)"
  results.clear();
  rewriter.AdToEra(1393, &results);
  Expect2Results(results,
            "\xE6\x98\x8E\xE5\xBE\xB3" "4",
            "\xE6\x98\x8E\xE5\xBE\xB3\xE5\x9B\x9B");

  // AD.1375
  // South: "文中4(年)" or "文中四(年)", "天授元(年)"
  // North: "応安8(年)" or "応安八(年)", "永和元(年)"
  results.clear();
  rewriter.AdToEra(1375, &results);
  // just checks number.
  EXPECT_EQ(results.size(), 6);

  // AD.1332
  // South: "元弘2(年)" or "元弘二(年)"
  // North: "正慶元(年)", "元徳4(年)" or "元徳四(年)"
  results.clear();
  rewriter.AdToEra(1332, &results);
  EXPECT_EQ(results.size(), 5);
  Expect5Results(results,
                 "\xE5\x85\x83\xE5\xBC\x98" "2",
                 "\xE5\x85\x83\xE5\xBC\x98\xE4\xBA\x8C",
                 "\xE6\xAD\xA3\xE6\x85\xB6\xE5\x85\x83",
                 "\xE5\x85\x83\xE5\xBE\xB3" "4",
                 "\xE5\x85\x83\xE5\xBE\xB3\xE5\x9B\x9B");
  // AD.1333
  // South: "元弘3" or "元弘三(年)"
  // North: "正慶2" or "正慶二(年)"
  results.clear();
  rewriter.AdToEra(1333, &results);
  Expect4Results(results,
                 "\xE5\x85\x83\xE5\xBC\x98" "3",
                 "\xE5\x85\x83\xE5\xBC\x98\xE4\xB8\x89",
                 "\xE6\xAD\xA3\xE6\x85\xB6" "2",
                 "\xE6\xAD\xA3\xE6\x85\xB6\xE4\xBA\x8C");

  // AD.1334
  // South: "元弘4" or "元弘四(年)", "建武元"
  // North: "正慶3" or "正慶三(年)", "建武元(deduped)"
  results.clear();
  rewriter.AdToEra(1334, &results);
  EXPECT_EQ(results.size(), 5);
  Expect5Results(results,
                 "\xE5\x85\x83\xE5\xBC\x98" "4",
                 "\xE5\x85\x83\xE5\xBC\x98\xE5\x9B\x9B",
                 "\xE5\xBB\xBA\xE6\xAD\xA6\xE5\x85\x83",
                 "\xE6\xAD\xA3\xE6\x85\xB6\xE4\xB8\x89",
                 "\xE6\xAD\xA3\xE6\x85\xB6" "3");

  // AD.1997
  // "平成九年"
  results.clear();
  rewriter.AdToEra(1997, &results);
  EXPECT_EQ(results.size(), 2);
  Expect2Results(results,
                 "\xE5\xB9\xB3\xE6\x88\x90" "9",
                 "\xE5\xB9\xB3\xE6\x88\x90\xE4\xB9\x9D");

  // AD.2011
  // "平成二十三年"
  results.clear();
  rewriter.AdToEra(2011, &results);
  EXPECT_EQ(results.size(), 2);
  Expect2Results(
      results,
      "\xE5\xB9\xB3\xE6\x88\x90" "23",
      "\xE5\xB9\xB3\xE6\x88\x90\xE4\xBA\x8C\xE5\x8D\x81\xE4\xB8\x89");

  // AD.1998
  // "平成十年" or "平成10年"
  results.clear();
  rewriter.AdToEra(1998, &results);
  EXPECT_EQ(results.size(), 2);
  Expect2Results(results,
                 "\xE5\xB9\xB3\xE6\x88\x90" "10",
                 "\xE5\xB9\xB3\xE6\x88\x90\xE5\x8D\x81");

  // Negative Test
  // Too big number or negative number input are expected false return
  results.clear();
  EXPECT_FALSE(rewriter.AdToEra(2100, &results));
  EXPECT_FALSE(rewriter.AdToEra(-100, &results));
}

TEST_F(DateRewriterTest, ERAToAD) {
  DateRewriter rewriter;
  vector<string> results, descriptions;
  const ConversionRequest request;
  // "1234", "１２３４", "一二三四"
  const int kNumYearRepresentation = 3;

  results.clear();
  descriptions.clear();
  rewriter.EraToAd("", &results, &descriptions);
  EXPECT_EQ(0, results.size());
  EXPECT_EQ(0, descriptions.size());

  // "たいか1ねん" is "645年" or "６４５年" or "六四五年"
  // "大化1年"
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x9F\xE3\x81\x84\xE3\x81\x8B"
                               "1" "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation, results.size());
  EXPECT_EQ(kNumYearRepresentation, descriptions.size());
  Expect3Results(results,
                 "645\xE5\xB9\xB4",
                 "\xE5\x85\xAD\xE5\x9B\x9B\xE4\xBA\x94\xE5\xB9\xB4",
                 "\xEF\xBC\x96\xEF\xBC\x94\xEF\xBC\x95\xE5\xB9\xB4");
  EXPECT_TRUE(AllElementsAreSame("\xE5\xA4\xA7\xE5\x8C\x96" "1" "\xE5\xB9\xB4",
                                 descriptions));

  // "たいか2ねん" is "646年" or "６４６年" or "六四六年"
  // "大化2年"
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x9F\xE3\x81\x84\xE3\x81\x8B"
                               "2" "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation, results.size());
  EXPECT_EQ(kNumYearRepresentation, descriptions.size());
  Expect3Results(results,
                 "646\xE5\xB9\xB4",
                 "\xEF\xBC\x96\xEF\xBC\x94\xEF\xBC\x96\xE5\xB9\xB4",
                 "\xE5\x85\xAD\xE5\x9B\x9B\xE5\x85\xAD\xE5\xB9\xB4");
  EXPECT_TRUE(AllElementsAreSame("\xE5\xA4\xA7\xE5\x8C\x96" "2" "\xE5\xB9\xB4",
                                 descriptions));

  // "しょうわ2ねん" is AD.1313 or AD.1927
  // "1313年", "１３１３年", "一三一三年"
  // "1927年", "１９２７年", "一九二七年"
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x97\xE3\x82\x87"
                               "\xE3\x81\x86\xE3\x82\x8F"
                               "2"
                               "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation * 2, results.size());
  EXPECT_EQ(kNumYearRepresentation * 2, descriptions.size());

  for (int i = 0; i < kNumYearRepresentation; ++i) {
    // "正和2年"
    EXPECT_EQ("\xE6\xAD\xA3\xE5\x92\x8C" "2" "\xE5\xB9\xB4", descriptions[i]);
    // "昭和2年"
    EXPECT_EQ("\xE6\x98\xAD\xE5\x92\x8C" "2" "\xE5\xB9\xB4",
              descriptions[i + kNumYearRepresentation]);
  }
  vector<string> first(results.begin(),
                       results.begin() + kNumYearRepresentation);
  vector<string> second(results.begin() + kNumYearRepresentation,
                        results.end());
  EXPECT_TRUE(IsStringContained("1313" "\xE5\xB9\xB4", first));
  EXPECT_TRUE(IsStringContained("\xEF\xBC\x91\xEF\xBC\x93\xEF\xBC\x91"
                                "\xEF\xBC\x93\xE5\xB9\xB4", first));
  EXPECT_TRUE(IsStringContained("\xE4\xB8\x80\xE4\xB8\x89\xE4\xB8\x80"
                                "\xE4\xB8\x89\xE5\xB9\xB4", first));
  EXPECT_TRUE(IsStringContained("1927" "\xE5\xB9\xB4", second));
  EXPECT_TRUE(IsStringContained("\xEF\xBC\x91\xEF\xBC\x99\xEF\xBC\x92"
                                "\xEF\xBC\x97\xE5\xB9\xB4", second));
  EXPECT_TRUE(IsStringContained("\xE4\xB8\x80\xE4\xB9\x9D\xE4\xBA\x8C"
                                "\xE4\xB8\x83\xE5\xB9\xB4", second));

  // North court test
  // "げんとく1ねん" is AD.1329
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x92\xE3\x82\x93"
                               "\xE3\x81\xA8\xE3\x81\x8F"
                               "1"
                               "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation, results.size());
  EXPECT_EQ(kNumYearRepresentation, descriptions.size());
  EXPECT_TRUE(IsStringContained("1329" "\xE5\xB9\xB4", results));
  // "めいとく3ねん" is AD.1392
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x82\x81\xE3\x81\x84"
                               "\xE3\x81\xA8\xE3\x81\x8F"
                               "3"
                               "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation, results.size());
  EXPECT_EQ(kNumYearRepresentation, descriptions.size());
  EXPECT_TRUE(IsStringContained("1392" "\xE5\xB9\xB4", results));
  // "けんむ1ねん" is AD.1334 (requires dedupe)
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x91\xE3\x82\x93\xE3\x82\x80"
                               "1"
                               "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation, results.size());
  EXPECT_EQ(kNumYearRepresentation, descriptions.size());
  EXPECT_TRUE(IsStringContained("1334" "\xE5\xB9\xB4", results));

  // Big number test
  // "昭和80年" is AD.2005
  // "しょうわ80ねん"
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x97\xE3\x82\x87"
                               "\xE3\x81\x86\xE3\x82\x8F"
                               "80"
                               "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_TRUE(IsStringContained("2005" "\xE5\xB9\xB4", results));
  // "大正101年" is AD.2012
  // "たいしょう101ねん"
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x9F\xE3\x81\x84"
                               "\xE3\x81\x97\xE3\x82\x87\xE3\x81\x86"
                               "101" "\xE3\x81\xAD\xE3\x82\x93",
                               &results, &descriptions));
  EXPECT_TRUE(IsStringContained("2012" "\xE5\xB9\xB4", results));

  // "元年" test
  // "へいせいがんねん" is AD.1989
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\xB8\xE3\x81\x84"
                               "\xE3\x81\x9B\xE3\x81\x84"
                               "\xE3\x81\x8C\xE3\x82\x93"
                               "\xE3\x81\xAD\xE3\x82\x93"
                               , &results, &descriptions));
  EXPECT_EQ(kNumYearRepresentation, results.size());
  EXPECT_EQ(kNumYearRepresentation, descriptions.size());
  // "1989年"
  EXPECT_TRUE(IsStringContained("1989" "\xE5\xB9\xB4", results));
  // "１９８９年"
  EXPECT_TRUE(IsStringContained("\xEF\xBC\x91\xEF\xBC\x99"
                                "\xEF\xBC\x98\xEF\xBC\x99"
                                "\xE5\xB9\xB4", results));
  // "一九八九年"
  EXPECT_TRUE(IsStringContained("\xE4\xB8\x80\xE4\xB9\x9D"
                                "\xE5\x85\xAB\xE4\xB9\x9D"
                                "\xE5\xB9\xB4", results));
  // description is "平成元年"
  EXPECT_TRUE(AllElementsAreSame("\xE5\xB9\xB3\xE6\x88\x90"
                                 "\xE5\x85\x83\xE5\xB9\xB4",
                                 descriptions));

  // "しょうわがんねん" is AD.1926 or AD.1312
  results.clear();
  descriptions.clear();
  EXPECT_TRUE(rewriter.EraToAd("\xE3\x81\x97\xE3\x82\x87"
                               "\xE3\x81\x86\xE3\x82\x8F"
                               "\xE3\x81\x8C\xE3\x82\x93"
                               "\xE3\x81\xAD\xE3\x82\x93"
                               , &results, &descriptions));
  EXPECT_EQ(2 * kNumYearRepresentation, results.size());
  EXPECT_EQ(2 * kNumYearRepresentation, descriptions.size());
  // "1926年"
  EXPECT_TRUE(IsStringContained("1926" "\xE5\xB9\xB4", results));
  // "１９２６年"
  EXPECT_TRUE(IsStringContained("\xEF\xBC\x91\xEF\xBC\x99"
                                "\xEF\xBC\x92\xEF\xBC\x96"
                                "\xE5\xB9\xB4", results));
  // "一九二六年"
  EXPECT_TRUE(IsStringContained("\xE4\xB8\x80\xE4\xB9\x9D"
                                "\xE4\xBA\x8C\xE5\x85\xAD"
                                "\xE5\xB9\xB4", results));
  // "1312年"
  EXPECT_TRUE(IsStringContained("1312" "\xE5\xB9\xB4", results));
  // "１３１２年"
  EXPECT_TRUE(IsStringContained("\xEF\xBC\x91\xEF\xBC\x93"
                                "\xEF\xBC\x91\xEF\xBC\x92"
                                "\xE5\xB9\xB4", results));
  // "一三一二年"
  EXPECT_TRUE(IsStringContained("\xE4\xB8\x80\xE4\xB8\x89"
                                "\xE4\xB8\x80\xE4\xBA\x8C"
                                "\xE5\xB9\xB4", results));

  // Negative Test
  // 0 or negative number input are expected false return
  results.clear();
  descriptions.clear();
  EXPECT_FALSE(rewriter.EraToAd("\xE3\x81\x97\xE3\x82\x87"
                                "\xE3\x81\x86\xE3\x82\x8F"
                                "-1"
                                "\xE3\x81\xAD\xE3\x82\x93",
                                &results, &descriptions));
  EXPECT_FALSE(rewriter.EraToAd("\xE3\x81\x97\xE3\x82\x87"
                                "\xE3\x81\x86\xE3\x82\x8F"
                                "0"
                                "\xE3\x81\xAD\xE3\x82\x93",
                                &results, &descriptions));
  EXPECT_FALSE(rewriter.EraToAd(""
                                "0"
                                "\xE3\x81\xAD\xE3\x82\x93",
                                &results, &descriptions));
  EXPECT_EQ(0, results.size());
  EXPECT_EQ(0, descriptions.size());
}

TEST_F(DateRewriterTest, ConvertTime) {
  DateRewriter rewriter;
  vector<string> results;
  const ConversionRequest request;

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(0, 0, &results));

  // "0時00分, 午前0時00分"
  Expect3Results(results,
                 "0:00",
                 "0"
                 "\xE6\x99\x82"
                 "00"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\x89\x8D"
                 "0"
                 "\xE6\x99\x82"
                 "0"
                 "\xE5\x88\x86");

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(9, 9, &results));

  // "9時09分, 午前9時09分"
  Expect3Results(results,
                 "9:09",
                 "9"
                 "\xE6\x99\x82"
                 "09"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\x89\x8D"
                 "9"
                 "\xE6\x99\x82"
                 "9"
                 "\xE5\x88\x86");

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(11, 59, &results));

  // "11時59分, 午前11時59分"
  Expect3Results(results,
                 "11:59",
                 "11"
                 "\xE6\x99\x82"
                 "59"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\x89\x8D"
                 "11"
                 "\xE6\x99\x82"
                 "59"
                 "\xE5\x88\x86");

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(12, 0, &results));

  // "12時00分, 午後0時0分"
  Expect3Results(results,
                 "12:00",
                 "12"
                 "\xE6\x99\x82"
                 "00"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\xBE\x8C"
                 "0"
                 "\xE6\x99\x82"
                 "0"
                 "\xE5\x88\x86");

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(12, 1, &results));

  // "12時01分, 午後0時1分"
  Expect3Results(results,
                 "12:01",
                 "12"
                 "\xE6\x99\x82"
                 "01"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\xBE\x8C"
                 "0"
                 "\xE6\x99\x82"
                 "1"
                 "\xE5\x88\x86");

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(19, 23, &results));

  // "19時23分, 午後7時23分"
  Expect3Results(results,
                 "19:23",
                 "19"
                 "\xE6\x99\x82"
                 "23"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\xBE\x8C"
                 "7"
                 "\xE6\x99\x82"
                 "23"
                 "\xE5\x88\x86");

  results.clear();
  EXPECT_TRUE(rewriter.ConvertTime(25, 23, &results));

  // "25時23分, 午前1時23分"
  Expect3Results(results,
                 "25:23",
                 "25"
                 "\xE6\x99\x82"
                 "23"
                 "\xE5\x88\x86",
                 "\xE5\x8D\x88\xE5\x89\x8D"
                 "1"
                 "\xE6\x99\x82"
                 "23"
                 "\xE5\x88\x86");

  results.clear();

  // "18:30,18時30分、18時半、午後6時30分、午後6時半"
  // And the order of results is must be above.
  EXPECT_TRUE(rewriter.ConvertTime(18, 30, &results));
  ASSERT_EQ(5, results.size());
  EXPECT_EQ("18:30", results[0]);
  EXPECT_EQ("\x31\x38\xE6\x99\x82\x33\x30\xE5\x88\x86", results[1]);
  EXPECT_EQ("\x31\x38\xE6\x99\x82\xE5\x8D\x8A", results[2]);
  EXPECT_EQ("\xE5\x8D\x88\xE5\xBE\x8C\x36\xE6\x99\x82\x33\x30\xE5\x88\x86",
            results[3]);
  EXPECT_EQ("\xE5\x8D\x88\xE5\xBE\x8C\x36\xE6\x99\x82\xE5\x8D\x8A", results[4]);
  results.clear();

  EXPECT_FALSE(rewriter.ConvertTime(-10, 20, &results));
  EXPECT_FALSE(rewriter.ConvertTime(10, -20, &results));
  EXPECT_FALSE(rewriter.ConvertTime(80, 20, &results));
  EXPECT_FALSE(rewriter.ConvertTime(20, 80, &results));
  EXPECT_FALSE(rewriter.ConvertTime(30, 80, &results));
}

TEST_F(DateRewriterTest, ConvertDateTest) {
  DateRewriter rewriter;
  vector<string> results;

  results.clear();
  EXPECT_TRUE(rewriter.ConvertDateWithYear(2011, 4, 17, &results));
  ASSERT_EQ(3, results.size());
  // "2011年4月17日"
  EXPECT_TRUE(IsStringContained("2011" "\xE5\xB9\xB4"
                                "4" "\xE6\x9C\x88"
                                "17" "\xE6\x97\xA5",
                                results));
  EXPECT_TRUE(IsStringContained("2011-04-17", results));
  EXPECT_TRUE(IsStringContained("2011/04/17", results));

  // January, March, May, July, Auguest, October, December has 31 days
  // April, June, September, November has 30 days
  // February is dealt as a special case, see below
  const struct {
    int month;
    int days;
  } month_days_test_data[] = {
    { 1, 31 },
    { 3, 31 },
    { 4, 30 },
    { 5, 31 },
    { 6, 30 },
    { 7, 31 },
    { 8, 31 },
    { 9, 30 },
    { 10, 31 },
    { 11, 30 },
    { 12, 31 }
  };

  for (size_t i = 0; i < arraysize(month_days_test_data); ++i) {
    EXPECT_TRUE(rewriter.ConvertDateWithYear(
        2001,
        month_days_test_data[i].month,
        month_days_test_data[i].days,
        &results));
    EXPECT_FALSE(rewriter.ConvertDateWithYear(
        2001,
        month_days_test_data[i].month,
        month_days_test_data[i].days+1,
        &results));
    ASSERT_TRUE(rewriter.ConvertDateWithoutYear(
        month_days_test_data[i].month,
        month_days_test_data[i].days,
        &results));
    ASSERT_FALSE(rewriter.ConvertDateWithoutYear(
        month_days_test_data[i].month,
        month_days_test_data[i].days + 1,
        &results));
  }

  // 4 dividable year is leap year.
  results.clear();
  EXPECT_TRUE(rewriter.ConvertDateWithYear(2004, 2, 29, &results));
  ASSERT_EQ(3, results.size());
  // "2004年2月29日"
  EXPECT_TRUE(IsStringContained("2004" "\xE5\xB9\xB4"
                                "2" "\xE6\x9C\x88"
                                "29" "\xE6\x97\xA5",
                                results));
  EXPECT_TRUE(IsStringContained("2004-02-29", results));
  EXPECT_TRUE(IsStringContained("2004/02/29", results));

  // Non 4 dividable year is not leap year.
  EXPECT_FALSE(rewriter.ConvertDateWithYear(1999, 2, 29, &results));

  // However, 100 dividable year is not leap year.
  EXPECT_FALSE(rewriter.ConvertDateWithYear(1900, 2, 29, &results));

  // Furthermore, 400 dividable year is leap year.
  results.clear();
  EXPECT_TRUE(rewriter.ConvertDateWithYear(2000, 2, 29, &results));
  ASSERT_EQ(3, results.size());
  // "2000年2月29日"
  EXPECT_TRUE(IsStringContained("2000" "\xE5\xB9\xB4"
                                "2" "\xE6\x9C\x88"
                                "29" "\xE6\x97\xA5",
                                results));
  EXPECT_TRUE(IsStringContained("2000-02-29", results));
  EXPECT_TRUE(IsStringContained("2000/02/29", results));

  EXPECT_FALSE(rewriter.ConvertDateWithYear(0, 1, 1, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithYear(2000, 13, 1, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithYear(2000, 1, 41, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithYear(2000, 13, 41, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithYear(2000, 0, 1, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithYear(2000, 1, 0, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithYear(2000, 0, 0, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithoutYear(13, 1, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithoutYear(1, 41, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithoutYear(13, 41, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithoutYear(0, 1, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithoutYear(1, 0, &results));
  EXPECT_FALSE(rewriter.ConvertDateWithoutYear(0, 0, &results));
}

TEST_F(DateRewriterTest, NumberRewriterTest) {
  Segments segments;
  DateRewriter rewriter;
  const commands::Request &request = commands::Request::default_instance();
  const composer::Composer composer(NULL, &request);
  const ConversionRequest conversion_request(&composer, &request);

  // 0101 is expected 3 time candidate and 2 date candidates
  InitSegment("0101", "0101", &segments);
  EXPECT_TRUE(rewriter.Rewrite(conversion_request, &segments));
  // "時刻"
  EXPECT_EQ(3, CountDescription(segments,
                                "\xE6\x99\x82\xE5\x88\xBB"));
  // "午前1時1分"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\xE5\x8D\x88\xE5\x89\x8D\x31\xE6\x99\x82\x31\xE5\x88\x86"));
  // "1時01分"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\x31\xE6\x99\x82\x30\x31\xE5\x88\x86"));
  EXPECT_TRUE(ContainCandidate(segments, "1:01"));

  // "日付"
  EXPECT_EQ(2, CountDescription(
      segments,
      "\xE6\x97\xA5\xE4\xBB\x98"));
  // "1月1日"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\x31\xE6\x9C\x88\x31\xE6\x97\xA5"));
  EXPECT_TRUE(ContainCandidate(segments, "01/01"));

  // 1830 is expected 5 time candidate and 0 date candidates
  InitSegment("1830", "1830", &segments);
  EXPECT_TRUE(rewriter.Rewrite(conversion_request, &segments));
  // "時刻"
  EXPECT_EQ(5, CountDescription(segments,
                                "\xE6\x99\x82\xE5\x88\xBB"));
  // "18時半"
  EXPECT_TRUE(ContainCandidate(segments,
                               "\x31\x38\xE6\x99\x82\xE5\x8D\x8A"));
  // "午後6時30分"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\xE5\x8D\x88\xE5\xBE\x8C\x36\xE6\x99\x82\x33\x30\xE5\x88\x86"));
  // "18時30分"
  EXPECT_TRUE(ContainCandidate(segments,
                               "\x31\x38\xE6\x99\x82\x33\x30\xE5\x88\x86"));
  // "午後6時半"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\xE5\x8D\x88\xE5\xBE\x8C\x36\xE6\x99\x82\xE5\x8D\x8A"));
  EXPECT_TRUE(ContainCandidate(segments, "18:30"));

  // "日付"
  EXPECT_EQ(0, CountDescription(segments, "\xE6\x97\xA5\xE4\xBB\x98"));

  // Especially for mobile, look at meta candidates' value, too.
  // "あかあか" on 12keys layout will be transliterated to "1212".
  InitMetaSegment(
      "\xE3\x81\x82\xE3\x81\x8B\xE3\x81\x82\xE3\x81\x8B", "1212", &segments);
  EXPECT_TRUE(rewriter.Rewrite(conversion_request, &segments));
  // "時刻"
  EXPECT_EQ(3, CountDescription(segments,
                                "\xE6\x99\x82\xE5\x88\xBB"));
  // "午後0時12分"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\xE5\x8d\x88\xE5\xBE\x8C\x30\xE6\x99\x82\x31\x32\xE5\x88\x86"));
  // "12時12分"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\x31\x32\xE6\x99\x82\x31\x32\xE5\x88\x86"));
  EXPECT_TRUE(ContainCandidate(segments, "12:12"));

  // "日付"
  EXPECT_EQ(2, CountDescription(
      segments,
      "\xE6\x97\xA5\xE4\xBB\x98"));
  // "12月12日"
  EXPECT_TRUE(ContainCandidate(
      segments,
      "\x31\x32\xE6\x9C\x88\x31\x32\xE6\x97\xA5"));
  EXPECT_TRUE(ContainCandidate(segments, "12/12"));

  // Invalid date or time number expect false return
  InitSegment("9999", "9999", &segments);
  EXPECT_FALSE(rewriter.Rewrite(conversion_request, &segments));
}

TEST_F(DateRewriterTest, NumberRewriterFromRawInputTest) {
  Segments segments;
  DateRewriter rewriter;

  composer::Table table;
  table.AddRule("222", "c", "");
  table.AddRule("3", "d", "");

  composer::Composer composer(&table, NULL);
  const ConversionRequest conversion_request(&composer, NULL);

  // Key sequence : 2223
  // Preedit : cd
  // In this case date/time candidates should be created from 2223.
  {
    InitSegment("cd", "cd", &segments);
    composer.Reset();
    composer.InsertCharacter("2223");
    EXPECT_TRUE(rewriter.Rewrite(conversion_request, &segments));
    EXPECT_TRUE(ContainCandidate(segments, "22:23"));
  }

  // Key sequence : 2223
  // Preedit : 1111
  // Meta candidate(HALF_ASCII)
  // Preedit should be prioritized over key sequence.
  {
    InitSegment("1111", "1111", &segments);
    composer.Reset();
    composer.InsertCharacter("2223");
    EXPECT_TRUE(rewriter.Rewrite(conversion_request, &segments));
    EXPECT_TRUE(ContainCandidate(segments, "11:11"));
    EXPECT_FALSE(ContainCandidate(segments, "22:23"));
  }

  // Key sequence : 2223
  // Preedit : cd
  // HALF_ASCII meta candidate: 1111
  // In this case meta candidates should be prioritized.
  {
    InitSegment("cd", "cd", &segments);
    Segment::Candidate *meta_candidate =
        segments.mutable_conversion_segment(0)->add_meta_candidate();
    meta_candidate->value = "1111";
    composer.InsertCharacter("2223");
    composer.Reset();
    EXPECT_TRUE(rewriter.Rewrite(conversion_request, &segments));
    EXPECT_TRUE(ContainCandidate(segments, "11:11"));
    EXPECT_FALSE(ContainCandidate(segments, "22:23"));
  }
}

TEST_F(DateRewriterTest, MobileEnvironmentTest) {
  commands::Request input;
  DateRewriter rewriter;

  {
    input.set_mixed_conversion(true);
    const ConversionRequest request(NULL, &input);
    EXPECT_EQ(RewriterInterface::ALL, rewriter.capability(request));
  }

  {
    input.set_mixed_conversion(false);
    const ConversionRequest request(NULL, &input);
    EXPECT_EQ(RewriterInterface::CONVERSION, rewriter.capability(request));
  }
}

TEST_F(DateRewriterTest, RewriteYearTest) {
  DateRewriter rewriter;
  Segments segments;
  const ConversionRequest request;

  InitSegment("2010", "2010", &segments);
  // "年"
  AppendSegment("nenn", "\xE5\xB9\xB4", &segments);

  EXPECT_TRUE(rewriter.Rewrite(request, &segments));
  // "平成22"
  EXPECT_TRUE(ContainCandidate(segments, "\xE5\xB9\xB3\xE6\x88\x90\x32\x32"));
}

// This test treats the situation that if UserHistoryRewriter or other like
// Rewriter moves up a candidate which is actually a number but can not be
// converted integer easily.
TEST_F(DateRewriterTest, RelationWithUserHistoryRewriterTest) {
  DateRewriter rewriter;
  Segments segments;
  const ConversionRequest request;

  // "二千十一"
  InitSegment("2011",
              "\xE4\xBA\x8C\xE5\x8D\x83\xE5\x8D\x81\xE4\xB8\x80",
              &segments);
  // "年"
  AppendSegment("nenn", "\xE5\xB9\xB4", &segments);

  EXPECT_TRUE(rewriter.Rewrite(request, &segments));
  // "平成23"
  EXPECT_TRUE(ContainCandidate(segments, "\xE5\xB9\xB3\xE6\x88\x90\x32\x33"));
}

}  // namespace mozc