// 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 "base/number_util.h"

#include "base/port.h"
#include "testing/base/public/googletest.h"
#include "testing/base/public/gunit.h"

namespace mozc {
namespace {

TEST(NumberUtilTest, SimpleItoa) {
  EXPECT_EQ("0",   NumberUtil::SimpleItoa(0));
  EXPECT_EQ("123", NumberUtil::SimpleItoa(123));
  EXPECT_EQ("-1",  NumberUtil::SimpleItoa(-1));

  EXPECT_EQ("2147483647",  NumberUtil::SimpleItoa(kint32max));
  EXPECT_EQ("-2147483648", NumberUtil::SimpleItoa(kint32min));
  EXPECT_EQ("4294967295",  NumberUtil::SimpleItoa(kuint32max));

  EXPECT_EQ("9223372036854775807",  NumberUtil::SimpleItoa(kint64max));
  EXPECT_EQ("-9223372036854775808", NumberUtil::SimpleItoa(kint64min));
  EXPECT_EQ("18446744073709551615", NumberUtil::SimpleItoa(kuint64max));
}

TEST(NumberUtilTest, SimpleAtoi) {
  EXPECT_EQ(0, NumberUtil::SimpleAtoi("0"));
  EXPECT_EQ(123, NumberUtil::SimpleAtoi("123"));
  EXPECT_EQ(-1, NumberUtil::SimpleAtoi("-1"));
}

TEST(NumberUtilTest, SafeStrToInt32) {
  int32 value = 0xDEADBEEF;

  EXPECT_TRUE(NumberUtil::SafeStrToInt32("0", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("+0", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("-0", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32(" \t\r\n\v\f-0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("012345678", &value));
  EXPECT_EQ(12345678, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("-012345678", &value));
  EXPECT_EQ(-12345678, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("-2147483648", &value));
  EXPECT_EQ(kint32min, value);  // min of 32-bit signed integer
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("2147483647", &value));
  EXPECT_EQ(kint32max, value);  // max of 32-bit signed integer
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32(" 1", &value));
  EXPECT_EQ(1, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt32("2 ", &value));
  EXPECT_EQ(2, value);

  EXPECT_FALSE(NumberUtil::SafeStrToInt32("0x1234", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32("-2147483649", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32("2147483648", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32("18446744073709551616", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32("3e", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32("0.", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32(".0", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt32("", &value));

  // Test for StringPiece input.
  const char *kString = "123 abc 789";
  EXPECT_TRUE(NumberUtil::SafeStrToInt32(StringPiece(kString, 3),
                                         &value));
  EXPECT_EQ(123, value);
  EXPECT_FALSE(NumberUtil::SafeStrToInt32(StringPiece(kString + 4, 3),
                                          &value));
  EXPECT_TRUE(NumberUtil::SafeStrToInt32(StringPiece(kString + 8, 3),
                                         &value));
  EXPECT_EQ(789, value);
  EXPECT_TRUE(NumberUtil::SafeStrToInt32(StringPiece(kString + 7, 4),
                                         &value));
  EXPECT_EQ(789, value);
}

TEST(NumberUtilTest, SafeStrToInt64) {
  int64 value = 0xDEADBEEF;

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("0", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("+0", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("-0", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64(" \t\r\n\v\f-0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("012345678", &value));
  EXPECT_EQ(12345678, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("-012345678", &value));
  EXPECT_EQ(-12345678, value);
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("-9223372036854775808", &value));
  EXPECT_EQ(kint64min, value);  // min of 64-bit signed integer
  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToInt64("9223372036854775807", &value));
  EXPECT_EQ(kint64max, value);  // max of 64-bit signed integer

  EXPECT_FALSE(NumberUtil::SafeStrToInt64("-9223372036854775809",  // overflow
                                          &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt64("9223372036854775808",  // overflow
                                          &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt64("0x1234", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt64("3e", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt64("0.", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt64(".0", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToInt64("", &value));

  // Test for StringPiece input.
  const char *kString = "123 abc 789";
  EXPECT_TRUE(NumberUtil::SafeStrToInt64(StringPiece(kString, 3),
                                         &value));
  EXPECT_EQ(123, value);
  EXPECT_FALSE(NumberUtil::SafeStrToInt64(StringPiece(kString + 4, 3),
                                          &value));
  EXPECT_TRUE(NumberUtil::SafeStrToInt64(StringPiece(kString + 8, 3),
                                         &value));
  EXPECT_EQ(789, value);
}

TEST(NumberUtilTest, SafeStrToUInt32) {
  uint32 value = 0xDEADBEEF;

  EXPECT_TRUE(NumberUtil::SafeStrToUInt32("0", &value));
  EXPECT_EQ(0, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32("012345678", &value));
  EXPECT_EQ(12345678, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32("4294967295", &value));
  EXPECT_EQ(4294967295u, value);  // max of 32-bit unsigned integer

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32(" 1", &value));
  EXPECT_EQ(1, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32("2 ", &value));
  EXPECT_EQ(2, value);

  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("-0", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("0x1234", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("4294967296", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("18446744073709551616", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("3e", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("0.", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32(".0", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32("", &value));

  // Test for StringPiece input.
  const char *kString = "123 abc 789";
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32(StringPiece(kString, 3),
                                          &value));
  EXPECT_EQ(123, value);
  EXPECT_FALSE(NumberUtil::SafeStrToUInt32(StringPiece(kString + 4, 3),
                                           &value));
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32(StringPiece(kString + 8, 3),
                                          &value));
  EXPECT_EQ(789, value);
  EXPECT_TRUE(NumberUtil::SafeStrToUInt32(StringPiece(kString + 7, 4),
                                          &value));
  EXPECT_EQ(789, value);
}

TEST(NumberUtilTest, SafeHexStrToUInt32) {
  uint32 value = 0xDEADBEEF;

  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32("0", &value));
  EXPECT_EQ(0, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(
      NumberUtil::SafeHexStrToUInt32(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32("0ABCDE", &value));
  EXPECT_EQ(0xABCDE, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32("0abcde", &value));
  EXPECT_EQ(0xABCDE, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32("FFFFFFFF", &value));
  EXPECT_EQ(0xFFFFFFFF, value);  // max of 32-bit unsigned integer

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32("ffffffff", &value));
  EXPECT_EQ(0xFFFFFFFF, value);  // max of 32-bit unsigned integer

  EXPECT_FALSE(NumberUtil::SafeHexStrToUInt32("-0", &value));
  EXPECT_FALSE(
      NumberUtil::SafeHexStrToUInt32("100000000", &value));  // overflow
  EXPECT_FALSE(NumberUtil::SafeHexStrToUInt32("GHIJK", &value));
  EXPECT_FALSE(NumberUtil::SafeHexStrToUInt32("0.", &value));
  EXPECT_FALSE(NumberUtil::SafeHexStrToUInt32(".0", &value));
  EXPECT_FALSE(NumberUtil::SafeHexStrToUInt32("", &value));

  // Test for StringPiece input.
  const char *kString = "123 abc 5x";
  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32(StringPiece(kString, 3),
                                             &value));
  EXPECT_EQ(291, value);
  EXPECT_TRUE(NumberUtil::SafeHexStrToUInt32(StringPiece(kString + 4, 3),
                                             &value));
  EXPECT_EQ(2748, value);
  EXPECT_FALSE(NumberUtil::SafeHexStrToUInt32(StringPiece(kString + 8, 2),
                                              &value));
}

TEST(NumberUtilTest, SafeOctStrToUInt32) {
  uint32 value = 0xDEADBEEF;

  EXPECT_TRUE(NumberUtil::SafeOctStrToUInt32("0", &value));
  EXPECT_EQ(0, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(
      NumberUtil::SafeOctStrToUInt32(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeOctStrToUInt32("012345", &value));
  EXPECT_EQ(012345, value);

  value = 0xDEADBEEF;
  EXPECT_TRUE(NumberUtil::SafeOctStrToUInt32("37777777777", &value));
  EXPECT_EQ(0xFFFFFFFF, value);  // max of 32-bit unsigned integer

  EXPECT_FALSE(NumberUtil::SafeOctStrToUInt32("-0", &value));
  EXPECT_FALSE(
      NumberUtil::SafeOctStrToUInt32("40000000000", &value));  // overflow
  EXPECT_FALSE(NumberUtil::SafeOctStrToUInt32("9AB", &value));
  EXPECT_FALSE(NumberUtil::SafeOctStrToUInt32("0.", &value));
  EXPECT_FALSE(NumberUtil::SafeOctStrToUInt32(".0", &value));
  EXPECT_FALSE(NumberUtil::SafeOctStrToUInt32("", &value));

  // Test for StringPiece input.
  const char *kString = "123 456 789";
  EXPECT_TRUE(NumberUtil::SafeOctStrToUInt32(StringPiece(kString, 3),
                                             &value));
  EXPECT_EQ(83, value);
  EXPECT_TRUE(NumberUtil::SafeOctStrToUInt32(StringPiece(kString + 4, 3),
                                             &value));
  EXPECT_EQ(302, value);
  EXPECT_FALSE(NumberUtil::SafeOctStrToUInt32(StringPiece(kString + 8, 3),
                                              &value));
}

TEST(NumberUtilTest, SafeStrToUInt64) {
  uint64 value = 0xDEADBEEF;

  EXPECT_TRUE(NumberUtil::SafeStrToUInt64("0", &value));
  EXPECT_EQ(0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToUInt64(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToUInt64("012345678", &value));
  EXPECT_EQ(12345678, value);
  EXPECT_TRUE(NumberUtil::SafeStrToUInt64("18446744073709551615", &value));
  EXPECT_EQ(18446744073709551615ull, value);  // max of 64-bit unsigned integer

  EXPECT_FALSE(NumberUtil::SafeStrToUInt64("-0", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64("18446744073709551616",  // overflow
                                     &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64("0x1234", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64("3e", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64("0.", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64(".0", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64("", &value));

  // Test for StringPiece input.
  const char *kString = "123 abc 789";
  EXPECT_TRUE(NumberUtil::SafeStrToUInt64(StringPiece(kString, 3),
                                          &value));
  EXPECT_EQ(123, value);
  EXPECT_FALSE(NumberUtil::SafeStrToUInt64(StringPiece(kString + 4, 3),
                                           &value));
  EXPECT_TRUE(NumberUtil::SafeStrToUInt64(StringPiece(kString + 8, 3),
                                          &value));
  EXPECT_EQ(789, value);
}

TEST(NumberUtilTest, SafeStrToDouble) {
  double value = 1.0;

  EXPECT_TRUE(NumberUtil::SafeStrToDouble("0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("-0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("1.0e1", &value));
  EXPECT_EQ(10.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("-5.0e-1", &value));
  EXPECT_EQ(-0.5, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble(".0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("0.", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("0.0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("1.7976931348623158e308", &value));
  EXPECT_EQ(1.7976931348623158e308, value);  // approximated representation
                                             // of max of double
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("-1.7976931348623158e308", &value));
  EXPECT_EQ(-1.7976931348623158e308, value);

  // We don't strongly assert that a hexadecimal number can be accepted with
  // Visual C++.
#if defined(_MSC_VER)
  if (NumberUtil::SafeStrToDouble("0x1234", &value)) {
    EXPECT_EQ(static_cast<double>(0x1234), value);
  }
#else
  EXPECT_TRUE(NumberUtil::SafeStrToDouble("0x1234", &value));
  EXPECT_EQ(static_cast<double>(0x1234), value);
#endif  // _MSC_VER or else.

  EXPECT_FALSE(
      NumberUtil::SafeStrToDouble("1.7976931348623159e308",
                                  &value));  // overflow
  EXPECT_FALSE(NumberUtil::SafeStrToDouble("-1.7976931348623159e308", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToDouble("3e", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToDouble(".", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToDouble("", &value));

  // Test for StringPiece input.
  const char *kString = "0.01 3.1415 double";
  EXPECT_TRUE(NumberUtil::SafeStrToDouble(StringPiece(kString, 4),
                                          &value));
  EXPECT_EQ(0.01, value);
  EXPECT_TRUE(NumberUtil::SafeStrToDouble(StringPiece(kString + 5, 6),
                                          &value));
  EXPECT_EQ(3.1415, value);
  EXPECT_FALSE(NumberUtil::SafeStrToDouble(StringPiece(kString + 12, 6),
                                           &value));
}

TEST(NumberUtilTest, SafeStrToFloat) {
  float value = 1.0;

  EXPECT_TRUE(NumberUtil::SafeStrToFloat("0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat(" \t\r\n\v\f0 \t\r\n\v\f", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat("-0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat("1.0e1", &value));
  EXPECT_EQ(10.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat("-5.0e-1", &value));
  EXPECT_EQ(-0.5, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat(".0", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat("0.", &value));
  EXPECT_EQ(0.0, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat("0.0", &value));
  EXPECT_EQ(0.0, value);
  // We don't strongly assert that a hexadecimal number can be accepted with
  // Visual C++.
#if defined(_MSC_VER)
  if (NumberUtil::SafeStrToFloat("0x1234", &value)) {
    EXPECT_EQ(static_cast<float>(0x1234), value);
  }
#else
  EXPECT_TRUE(NumberUtil::SafeStrToFloat("0x1234", &value));
  EXPECT_EQ(static_cast<float>(0x1234), value);
#endif  // _MSC_VER or else.

  EXPECT_FALSE(NumberUtil::SafeStrToFloat("3.4028236e38",  // overflow
                                          &value));
  EXPECT_FALSE(NumberUtil::SafeStrToFloat("-3.4028236e38", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToFloat("3e", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToFloat(".", &value));
  EXPECT_FALSE(NumberUtil::SafeStrToFloat("", &value));

  // Test for StringPiece input.
  const char *kString = "0.01 3.14 float";
  EXPECT_TRUE(NumberUtil::SafeStrToFloat(StringPiece(kString, 4),
                                         &value));
  EXPECT_EQ(0.01f, value);
  EXPECT_TRUE(NumberUtil::SafeStrToFloat(StringPiece(kString + 5, 4),
                                         &value));
  EXPECT_EQ(3.14f, value);
  EXPECT_FALSE(NumberUtil::SafeStrToFloat(StringPiece(kString + 10, 5),
                                          &value));
}

TEST(NumberUtilTest, StrToFloat) {
  EXPECT_EQ(0.0, NumberUtil::StrToFloat("0"));
  EXPECT_EQ(0.0, NumberUtil::StrToFloat(" \t\r\n\v\f0 \t\r\n\v\f"));
  EXPECT_EQ(0.0, NumberUtil::StrToFloat("-0"));
  EXPECT_EQ(10.0, NumberUtil::StrToFloat("1.0e1"));
  EXPECT_EQ(-0.5, NumberUtil::StrToFloat("-5.0e-1"));
  EXPECT_EQ(0.0, NumberUtil::StrToFloat(".0"));
  EXPECT_EQ(0.0, NumberUtil::StrToFloat("0."));
  EXPECT_EQ(0.0, NumberUtil::StrToFloat("0.0"));

  // Test for StringPiece input.
  const char *kString = "0.01 3.14";
  EXPECT_EQ(0.01f, NumberUtil::StrToFloat(StringPiece(kString, 4)));
  EXPECT_EQ(3.14f, NumberUtil::StrToFloat(StringPiece(kString + 5, 4)));
}

TEST(NumberUtilTest, IsArabicNumber) {
  EXPECT_FALSE(NumberUtil::IsArabicNumber(""));

  EXPECT_TRUE(NumberUtil::IsArabicNumber("0"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("1"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("2"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("3"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("4"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("5"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("6"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("7"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("8"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("9"));

  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x90"));  // ０
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x91"));  // １
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x92"));  // ２
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x93"));  // ３
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x94"));  // ４
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x95"));  // ５
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x96"));  // ６
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x97"));  // ７
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x98"));  // ８
  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x99"));  // ９

  EXPECT_TRUE(NumberUtil::IsArabicNumber("0123456789"));
  EXPECT_TRUE(NumberUtil::IsArabicNumber("01234567890123456789"));

  EXPECT_TRUE(NumberUtil::IsArabicNumber("\xEF\xBC\x91\xEF\xBC\x90"));  // １０

  EXPECT_FALSE(NumberUtil::IsArabicNumber("abc"));
  EXPECT_FALSE(NumberUtil::IsArabicNumber("\xe5\x8d\x81"));  // 十
  EXPECT_FALSE(NumberUtil::IsArabicNumber("\xe5\x84\x84"));  // 億
  // グーグル
  EXPECT_FALSE(NumberUtil::IsArabicNumber(
      "\xe3\x82\xb0\xe3\x83\xbc\xe3\x82\xb0\xe3\x83\xab"));
}

TEST(NumberUtilTest, IsDecimalInteger) {
  EXPECT_FALSE(NumberUtil::IsDecimalInteger(""));

  EXPECT_TRUE(NumberUtil::IsDecimalInteger("0"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("1"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("2"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("3"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("4"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("5"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("6"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("7"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("8"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("9"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("0123456789"));
  EXPECT_TRUE(NumberUtil::IsDecimalInteger("01234567890123456789"));

  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x90"));  // ０
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x91"));  // １
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x92"));  // ２
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x93"));  // ３
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x94"));  // ４
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x95"));  // ５
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x96"));  // ６
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x97"));  // ７
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x98"));  // ８
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x99"));  // ９

  // １０
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xEF\xBC\x91\xEF\xBC\x90"));
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xe5\x8d\x81"));  // 十
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("\xe5\x84\x84"));  // 億
  EXPECT_FALSE(NumberUtil::IsDecimalInteger("abc"));
  // グーグル
  EXPECT_FALSE(NumberUtil::IsDecimalInteger(
      "\xe3\x82\xb0\xe3\x83\xbc\xe3\x82\xb0\xe3\x83\xab"));
}

TEST(NumberUtilTest, KanjiNumberToArabicNumber) {
  const char *inputs[] = {
    // "十", "百", "千", "万", "億", "兆", "京"
    "\xe5\x8d\x81", "\xe7\x99\xbe", "\xe5\x8d\x83", "\xe4\xb8\x87",
    "\xe5\x84\x84", "\xe5\x85\x86", "\xe4\xba\xac"};
  const char *expects[] = {"10", "100", "1000", "10000", "100000000",
                           "1000000000000", "10000000000000000"};

  for (size_t i = 0; i < arraysize(inputs); ++i) {
    string arabic;
    NumberUtil::KanjiNumberToArabicNumber(inputs[i], &arabic);
    EXPECT_EQ(expects[i], arabic);
  }
}

TEST(NumberUtilTest, NormalizeNumbers) {
  // An element has input, expected Kanji output, and exepcted Arabic output.
  const char *success_data[][3] = {
    // "一"
    {"\xE4\xB8\x80", "\xE4\xB8\x80", "1"},
    // "九"
    {"\xE4\xB9\x9D", "\xE4\xB9\x9D", "9"},
    // "十"
    {"\xE5\x8D\x81", "\xE5\x8D\x81", "10"},
    // "十五"
    {"\xe5\x8d\x81\xe4\xba\x94", "\xe5\x8d\x81\xe4\xba\x94", "15"},
    // "二十"
    {"\xE4\xBA\x8C\xE5\x8D\x81", "\xE4\xBA\x8C\xE5\x8D\x81", "20"},
    // "三十五"
    {"\xE4\xB8\x89\xE5\x8D\x81\xE4\xBA\x94",
     "\xE4\xB8\x89\xE5\x8D\x81\xE4\xBA\x94", "35"},
    // "百"
    {"\xE7\x99\xBE", "\xE7\x99\xBE", "100"},
    // "二百"
    {"\xE4\xBA\x8C\xE7\x99\xBE", "\xE4\xBA\x8C\xE7\x99\xBE", "200"},
    // "二百十"
    {"\xE4\xBA\x8C\xE7\x99\xBE\xE5\x8D\x81",
     "\xE4\xBA\x8C\xE7\x99\xBE\xE5\x8D\x81", "210"},
    // "二百五十"
    {"\xE4\xBA\x8C\xE7\x99\xBE\xE4\xBA\x94\xE5\x8D\x81",
     "\xE4\xBA\x8C\xE7\x99\xBE\xE4\xBA\x94\xE5\x8D\x81", "250"},
    // "七百七十七"
    {"\xE4\xB8\x83\xE7\x99\xBE\xE4\xB8\x83\xE5\x8D\x81\xE4\xB8\x83",
     "\xE4\xB8\x83\xE7\x99\xBE\xE4\xB8\x83\xE5\x8D\x81\xE4\xB8\x83", "777"},
    // "千"
    {"\xe5\x8d\x83", "\xe5\x8d\x83", "1000"},
    // "一千"
    {"\xE4\xB8\x80\xE5\x8D\x83", "\xE4\xB8\x80\xE5\x8D\x83", "1000"},
    // "八千"
    {"\xE5\x85\xAB\xE5\x8D\x83", "\xE5\x85\xAB\xE5\x8D\x83", "8000"},
    // "八千七百三十九"
    {"\xE5\x85\xAB\xE5\x8D\x83\xE4\xB8\x83\xE7\x99\xBE\xE4\xB8\x89\xE5\x8D\x81"
     "\xE4\xB9\x9D",
     "\xE5\x85\xAB\xE5\x8D\x83\xE4\xB8\x83\xE7\x99\xBE\xE4\xB8\x89\xE5\x8D\x81"
     "\xE4\xB9\x9D", "8739"},
    // "一万二十五"
    {"\xe4\xb8\x80\xe4\xb8\x87\xe4\xba\x8c\xe5\x8d\x81\xe4\xba\x94",
     "\xe4\xb8\x80\xe4\xb8\x87\xe4\xba\x8c\xe5\x8d\x81\xe4\xba\x94", "10025"},
    // 2^64 - 1
    // "千八百四十四京六千七百四十四兆七百三十七億九百五十五万千六百十五"
    {"\xe5\x8d\x83\xe5\x85\xab\xe7\x99\xbe\xe5\x9b\x9b\xe5\x8d\x81\xe5\x9b\x9b"
     "\xe4\xba\xac\xe5\x85\xad\xe5\x8d\x83\xe4\xb8\x83\xe7\x99\xbe\xe5\x9b\x9b"
     "\xe5\x8d\x81\xe5\x9b\x9b\xe5\x85\x86\xe4\xb8\x83\xe7\x99\xbe\xe4\xb8\x89"
     "\xe5\x8d\x81\xe4\xb8\x83\xe5\x84\x84\xe4\xb9\x9d\xe7\x99\xbe\xe4\xba\x94"
     "\xe5\x8d\x81\xe4\xba\x94\xe4\xb8\x87\xe5\x8d\x83\xe5\x85\xad\xe7\x99\xbe"
     "\xe5\x8d\x81\xe4\xba\x94",
     "\xe5\x8d\x83\xe5\x85\xab\xe7\x99\xbe\xe5\x9b\x9b\xe5\x8d\x81\xe5\x9b\x9b"
     "\xe4\xba\xac\xe5\x85\xad\xe5\x8d\x83\xe4\xb8\x83\xe7\x99\xbe\xe5\x9b\x9b"
     "\xe5\x8d\x81\xe5\x9b\x9b\xe5\x85\x86\xe4\xb8\x83\xe7\x99\xbe\xe4\xb8\x89"
     "\xe5\x8d\x81\xe4\xb8\x83\xe5\x84\x84\xe4\xb9\x9d\xe7\x99\xbe\xe4\xba\x94"
     "\xe5\x8d\x81\xe4\xba\x94\xe4\xb8\x87\xe5\x8d\x83\xe5\x85\xad\xe7\x99\xbe"
     "\xe5\x8d\x81\xe4\xba\x94",
     "18446744073709551615"},
    // "百億百"
    {"\xE7\x99\xBE\xE5\x84\x84\xE7\x99\xBE",
     "\xE7\x99\xBE\xE5\x84\x84\xE7\x99\xBE", "10000000100"},
    // "一千京"
    {"\xe4\xb8\x80\xe5\x8d\x83\xe4\xba\xac",
     "\xe4\xb8\x80\xe5\x8d\x83\xe4\xba\xac", "10000000000000000000"},

    // Old Kanji numbers
    // "零"
    {"\xE9\x9B\xB6", "\xE9\x9B\xB6", "0"},
    // "拾"
    {"\xe6\x8b\xbe", "\xe6\x8b\xbe", "10"},
    // "拾四"
    {"\xe6\x8b\xbe\xe5\x9b\x9b", "\xe6\x8b\xbe\xe5\x9b\x9b", "14"},
    // "廿"
    {"\xE5\xBB\xBF", "\xE5\xBB\xBF", "20"},
    // "廿万廿"
    {"\xe5\xbb\xbf\xe4\xb8\x87\xe5\xbb\xbf",
     "\xe5\xbb\xbf\xe4\xb8\x87\xe5\xbb\xbf", "200020"},
    // "弐拾参"
    {"\xe5\xbc\x90\xe6\x8b\xbe\xe5\x8f\x82",
     "\xe5\xbc\x90\xe6\x8b\xbe\xe5\x8f\x82", "23"},
    // "零弐拾参"
    {"\xe9\x9b\xb6\xe5\xbc\x90\xe6\x8b\xbe\xe5\x8f\x82",
     "\xe9\x9b\xb6\xe5\xbc\x90\xe6\x8b\xbe\xe5\x8f\x82", "23"},

    // Array of Kanji number digits
    // "〇"
    {"0", "\xe3\x80\x87", "0"},
    // "〇〇"
    {"00", "\xe3\x80\x87\xe3\x80\x87", "0"},
    // "二三五"
    {"\xe4\xba\x8c\xe4\xb8\x89\xe4\xba\x94",
     "\xe4\xba\x8c\xe4\xb8\x89\xe4\xba\x94", "235"},
    // "０１２", "〇一二"
    {"\xef\xbc\x90\xef\xbc\x91\xef\xbc\x92",
     "\xe3\x80\x87\xe4\xb8\x80\xe4\xba\x8c", "12"},
    // "二零一一"
    {"\xE4\xBA\x8C\xE9\x9B\xB6\xE4\xB8\x80\xE4\xB8\x80",
     "\xE4\xBA\x8C\xE9\x9B\xB6\xE4\xB8\x80\xE4\xB8\x80", "2011"},

    // Combinations of several types
    // "二三五万四三"
    {"\xe4\xba\x8c\xe4\xb8\x89\xe4\xba\x94\xe4\xb8\x87\xe5\x9b\x9b\xe4\xb8\x89",
     "\xe4\xba\x8c\xe4\xb8\x89\xe4\xba\x94\xe4\xb8\x87\xe5\x9b\x9b\xe4\xb8\x89",
     "2350043"},
    // "二百三五万一"
    {"\xe4\xba\x8c\xe7\x99\xbe\xe4\xb8\x89\xe4\xba\x94\xe4\xb8\x87\xe4\xb8\x80",
     "\xe4\xba\x8c\xe7\x99\xbe\xe4\xb8\x89\xe4\xba\x94\xe4\xb8\x87\xe4\xb8\x80",
     "2350001"},
    // "2十5", "二十五"
    {"2""\xe5\x8d\x81""5", "\xe4\xba\x8c\xe5\x8d\x81\xe4\xba\x94", "25"},
    // "2千四十３"
    {"2""\xe5\x8d\x83\xe5\x9b\x9b\xe5\x8d\x81\xef\xbc\x93",
     // "二千四十三"
     "\xe4\xba\x8c\xe5\x8d\x83\xe5\x9b\x9b\xe5\x8d\x81\xe4\xb8\x89", "2043"},
    // "九０", "九〇"
    {"\xE4\xB9\x9D\xEF\xBC\x90", "\xE4\xB9\x9D\xE3\x80\x87", "90"},
  };

  for (size_t i = 0; i < arraysize(success_data); ++i) {
    string arabic_output = "dummy_text_arabic";
    string kanji_output = "dummy_text_kanji";
    EXPECT_TRUE(NumberUtil::NormalizeNumbers(success_data[i][0], true,
                                             &kanji_output, &arabic_output));
    EXPECT_EQ(success_data[i][1], kanji_output);
    EXPECT_EQ(success_data[i][2], arabic_output);
  }

  // An element has input, expected Kanji output, and exepcted Arabic output.
  const char *success_notrim_data[][3] = {
    // "０１２", "〇一二"
    {"\xef\xbc\x90\xef\xbc\x91\xef\xbc\x92",
     "\xe3\x80\x87\xe4\xb8\x80\xe4\xba\x8c", "012"},
    // "０00", "〇〇〇"
    {"\xef\xbc\x90\x30\x30", "\xe3\x80\x87\xe3\x80\x87\xe3\x80\x87",
     "000"},
    // "００１２", "〇〇一二"
    {"\xef\xbc\x90\xef\xbc\x90\xef\xbc\x91\xef\xbc\x92",
     "\xe3\x80\x87\xe3\x80\x87\xe4\xb8\x80\xe4\xba\x8c", "0012"},
    // "０零０１２", "〇零〇一二"
    {"\xef\xbc\x90\xe9\x9b\xb6\xef\xbc\x90\xef\xbc\x91\xef\xbc\x92",
     "\xe3\x80\x87\xe9\x9b\xb6\xe3\x80\x87\xe4\xb8\x80\xe4\xba\x8c", "00012"},
    // "〇"
    {"0", "\xe3\x80\x87", "0"},
    // "〇〇"
    {"00", "\xe3\x80\x87\xe3\x80\x87", "00"},
  };

  for (size_t i = 0; i < arraysize(success_notrim_data); ++i) {
    string arabic_output = "dummy_text_arabic";
    string kanji_output = "dummy_text_kanji";
    EXPECT_TRUE(NumberUtil::NormalizeNumbers(success_notrim_data[i][0], false,
                                             &kanji_output, &arabic_output));
    EXPECT_EQ(success_notrim_data[i][1], kanji_output);
    EXPECT_EQ(success_notrim_data[i][2], arabic_output);
  }

  // Test data expected to fail
  const char *fail_data[] = {
    // 2^64
    // "千八百四十四京六千七百四十四兆七百三十七億九百五十五万千六百十六"
    "\xe5\x8d\x83\xe5\x85\xab\xe7\x99\xbe\xe5\x9b\x9b\xe5\x8d\x81\xe5\x9b\x9b"
    "\xe4\xba\xac\xe5\x85\xad\xe5\x8d\x83\xe4\xb8\x83\xe7\x99\xbe\xe5\x9b\x9b"
    "\xe5\x8d\x81\xe5\x9b\x9b\xe5\x85\x86\xe4\xb8\x83\xe7\x99\xbe\xe4\xb8\x89"
    "\xe5\x8d\x81\xe4\xb8\x83\xe5\x84\x84\xe4\xb9\x9d\xe7\x99\xbe\xe4\xba\x94"
    "\xe5\x8d\x81\xe4\xba\x94\xe4\xb8\x87\xe5\x8d\x83\xe5\x85\xad\xe7\x99\xbe"
    "\xe5\x8d\x81\xe5\x85\xad",
    // "てすと"
    "\xe3\x81\xa6\xe3\x81\x99\xe3\x81\xa8",
    // "てすと２"
    "\xe3\x81\xa6\xe3\x81\x99\xe3\x81\xa8\xef\xbc\x92",
    // "一十"
    "\xE4\xB8\x80\xE5\x8D\x81",
    // "一百"
    "\xE4\xB8\x80\xE7\x99\xBE",
    // "万二千三百四十五" (lack of number before "万")
    "\xE4\xB8\x87\xE4\xBA\x8C\xE5\x8D\x83\xE4\xB8\x89\xE7\x99\xBE\xE5\x9B\x9B"
    "\xE5\x8D\x81\xE4\xBA\x94",
    // "三億一京" (large base, "京", after small one, "億")
    "\xE4\xB8\x89\xE5\x84\x84\xE4\xB8\x80\xE4\xBA\xAC",
    // "三百四百" (same base appears twice)
    "\xE4\xB8\x89\xE7\x99\xBE\xE5\x9B\x9B\xE7\x99\xBE",
    // "五億六億" (same base appears twice)
    "\xE4\xBA\x94\xE5\x84\x84\xE5\x85\xAD\xE5\x84\x84",
    // "二十三十" (same base appears twice)
    "\xE4\xBA\x8C\xE5\x8D\x81\xE4\xB8\x89\xE5\x8D\x81",
    // "二十百" (relatively large base "百" after "十")
    "\xE4\xBA\x8C\xE5\x8D\x81\xE7\x99\xBE",
    // "一二三四五六七八九十"
    "\xe4\xb8\x80\xe4\xba\x8c\xe4\xb8\x89\xe5\x9b\x9b\xe4\xba\x94\xe5\x85\xad"
    "\xe4\xb8\x83\xe5\x85\xab\xe4\xb9\x9d\xe5\x8d\x81",
    // "九九八十一"
    "\xE4\xB9\x9D\xE4\xB9\x9D\xE5\x85\xAB\xE5\x8D\x81\xE4\xB8\x80",
  };

  for (size_t i = 0; i < arraysize(fail_data); ++i) {
    string arabic_output, kanji_output;
    EXPECT_FALSE(NumberUtil::NormalizeNumbers(fail_data[i], true,
                                              &kanji_output, &arabic_output));
  }
}

TEST(NumberUtilTest, NormalizeNumbersWithSuffix) {
  {
    // Checks that kanji_output and arabic_output is cleared.
    // "一個"
    const string input = "\xE4\xB8\x80\xE5\x80\x8B";
    string arabic_output = "dummy_text_arabic";
    string kanji_output = "dummy_text_kanji";
    string suffix = "dummy_text_suffix";
    EXPECT_TRUE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                 &kanji_output,
                                                 &arabic_output,
                                                 &suffix));
    EXPECT_EQ("\xE4\xB8\x80", kanji_output);
    EXPECT_EQ("1", arabic_output);
    // "個"
    EXPECT_EQ("\xE5\x80\x8B", suffix);
  }

  {
    // "一万二十五個"
    const string input = "\xe4\xb8\x80\xe4\xb8\x87\xe4\xba\x8c\xe5\x8d\x81\xe4"
                         "\xba\x94\xE5\x80\x8B";
    string arabic_output, kanji_output, suffix;
    EXPECT_TRUE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                 &kanji_output,
                                                 &arabic_output,
                                                 &suffix));
    EXPECT_EQ("\xe4\xb8\x80\xe4\xb8\x87\xe4\xba\x8c\xe5\x8d\x81\xe4\xba\x94",
              kanji_output);
    EXPECT_EQ("10025", arabic_output);
    // "個"
    EXPECT_EQ("\xE5\x80\x8B", suffix);
  }

  {
    // "二百三五万一番目"
    const string input = "\xe4\xba\x8c\xe7\x99\xbe\xe4\xb8\x89\xe4\xba\x94\xe4"
                         "\xb8\x87\xe4\xb8\x80\xE7\x95\xAA\xE7\x9B\xAE";
    string arabic_output, kanji_output, suffix;
    EXPECT_TRUE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                 &kanji_output,
                                                 &arabic_output,
                                                 &suffix));
    // "二百三五万一"
    EXPECT_EQ("\xe4\xba\x8c\xe7\x99\xbe\xe4\xb8\x89\xe4\xba\x94\xe4"
              "\xb8\x87\xe4\xb8\x80", kanji_output);
    EXPECT_EQ("2350001", arabic_output);
    // "番目"
    EXPECT_EQ("\xE7\x95\xAA\xE7\x9B\xAE", suffix);
  }

  {
    // "てすと"
    const string input = "\xe3\x81\xa6\xe3\x81\x99\xe3\x81\xa8";
    string arabic_output, kanji_output, suffix;
    EXPECT_FALSE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                  &kanji_output,
                                                  &arabic_output,
                                                  &suffix));
  }

  {
    // "てすと２"
    const string input = "\xe3\x81\xa6\xe3\x81\x99\xe3\x81\xa8\xef\xbc\x92";
    string arabic_output, kanji_output, suffix;
    EXPECT_FALSE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                  &kanji_output,
                                                  &arabic_output,
                                                  &suffix));
  }

  // Tests for numbers less than 10.
  {
    // "零セット"
    const string input = "\xE9\x9B\xB6\xE3\x82\xBB\xE3\x83\x83\xE3\x83\x88";
    string arabic_output, kanji_output, suffix;
    EXPECT_TRUE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                 &kanji_output,
                                                 &arabic_output,
                                                 &suffix));
    // "零"
    EXPECT_EQ("\xE9\x9B\xB6", kanji_output);
    EXPECT_EQ("0", arabic_output);
    // "セット"
    EXPECT_EQ("\xE3\x82\xBB\xE3\x83\x83\xE3\x83\x88", suffix);
  }

  {
    // "九０ぷよ"
    const string input = "\xE4\xB9\x9D\xEF\xBC\x90\xE3\x81\xB7\xE3\x82\x88";
    string arabic_output, kanji_output, suffix;
    EXPECT_TRUE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                 &kanji_output,
                                                 &arabic_output,
                                                 &suffix));
    // "九〇"
    EXPECT_EQ("\xE4\xB9\x9D\xE3\x80\x87",
              kanji_output);
    EXPECT_EQ("90", arabic_output);
    // "ぷよ"
    EXPECT_EQ("\xE3\x81\xB7\xE3\x82\x88", suffix);
  }

  {
    // "三五$"
    const string input = "\xE4\xB8\x89\xE4\xBA\x94$";
    string arabic_output, kanji_output, suffix;
    EXPECT_TRUE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                 &kanji_output,
                                                 &arabic_output,
                                                 &suffix));
    // "三五"
    EXPECT_EQ("\xE4\xB8\x89\xE4\xBA\x94", kanji_output);
    EXPECT_EQ("35", arabic_output);
    EXPECT_EQ("$", suffix);
  }

  {
    // "二十三十に" (same base appears twice)
    const string input = "\xE4\xBA\x8C\xE5\x8D\x81\xE4\xB8\x89\xE5\x8D\x81"
        "\xE3\x81\xAB";
    string arabic_output, kanji_output, suffix;
    EXPECT_FALSE(NumberUtil::NormalizeNumbersWithSuffix(input, true,
                                                  &kanji_output,
                                                  &arabic_output,
                                                  &suffix));
  }
}

TEST(NumberUtilTest, ArabicToWideArabicTest) {
  string arabic;
  vector<NumberUtil::NumberString> output;

  arabic = "12345";
  output.clear();
  EXPECT_TRUE(NumberUtil::ArabicToWideArabic(arabic, &output));
  ASSERT_EQ(output.size(), 2);
  // "１２３４５"
  EXPECT_EQ("\xE4\xB8\x80\xE4\xBA\x8C"
            "\xE4\xB8\x89\xE5\x9B\x9B\xE4\xBA\x94", output[0].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_KANJI_ARABIC, output[0].style);
  // "一二三四五"
  EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x92"
            "\xEF\xBC\x93\xEF\xBC\x94\xEF\xBC\x95", output[1].value);
  EXPECT_EQ(NumberUtil::NumberString::DEFAULT_STYLE, output[1].style);

  arabic = "00123";
  output.clear();
  EXPECT_TRUE(NumberUtil::ArabicToWideArabic(arabic, &output));
  ASSERT_EQ(output.size(), 2);
  // "００１２３"
  EXPECT_EQ("\xE3\x80\x87\xE3\x80\x87"
            "\xE4\xB8\x80\xE4\xBA\x8C\xE4\xB8\x89", output[0].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_KANJI_ARABIC, output[0].style);
  // "〇〇一二三"
  EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x90"
            "\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93", output[1].value);
  EXPECT_EQ(NumberUtil::NumberString::DEFAULT_STYLE, output[1].style);

  arabic = "abcde";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToWideArabic(arabic, &output));
  EXPECT_EQ(output.size(), 0);

  arabic = "012abc345";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToWideArabic(arabic, &output));
  EXPECT_EQ(output.size(), 0);

  arabic = "0.001";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToWideArabic(arabic, &output));
  EXPECT_EQ(output.size(), 0);

  arabic = "-100";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToWideArabic(arabic, &output));
  EXPECT_EQ(output.size(), 0);

  arabic = "18446744073709551616";  // UINT_MAX + 1
  EXPECT_TRUE(NumberUtil::ArabicToWideArabic(arabic, &output));
  // "１８４４６７４４０７３７０９５５１６１６"
  EXPECT_EQ("\xE4\xB8\x80\xE5\x85\xAB\xE5\x9B\x9B\xE5\x9B\x9B\xE5\x85"
            "\xAD\xE4\xB8\x83\xE5\x9B\x9B\xE5\x9B\x9B\xE3\x80\x87\xE4"
            "\xB8\x83\xE4\xB8\x89\xE4\xB8\x83\xE3\x80\x87\xE4\xB9\x9D"
            "\xE4\xBA\x94\xE4\xBA\x94\xE4\xB8\x80\xE5\x85\xAD\xE4\xB8"
            "\x80\xE5\x85\xAD",
            output[0].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_KANJI_ARABIC, output[0].style);
}

namespace {
const int kMaxCandsInArabicToKanjiTest = 4;
struct ArabicToKanjiTestData {
  const char *input;
  const int expect_num;
  const char *expect_value[kMaxCandsInArabicToKanjiTest];
  const NumberUtil::NumberString::Style
  expect_style[kMaxCandsInArabicToKanjiTest];
};
}  // namespace

// ArabicToKanji TEST
TEST(NumberUtilTest, ArabicToKanjiTest) {
  const NumberUtil::NumberString::Style kOldKanji =
      NumberUtil::NumberString::NUMBER_OLD_KANJI;
  const NumberUtil::NumberString::Style kKanji =
      NumberUtil::NumberString::NUMBER_KANJI;
  const NumberUtil::NumberString::Style kHalfArabicKanji =
      NumberUtil::NumberString::NUMBER_ARABIC_AND_KANJI_HALFWIDTH;
  const NumberUtil::NumberString::Style kFullArabicKanji =
      NumberUtil::NumberString::NUMBER_ARABIC_AND_KANJI_FULLWIDTH;

  const ArabicToKanjiTestData kData[] = {
    // "零"
    {"0", 1, {"\xE9\x9B\xB6"}, {kOldKanji}},
    // "零"
    {"00000", 1, {"\xE9\x9B\xB6"}, {kOldKanji}},
    // "二", "弐"
    {"2", 2, {"\xE4\xBA\x8C", "\xE5\xBC\x90"}, {kKanji, kOldKanji}},
    // "壱拾" is needed to avoid mistakes. Please refer http://b/6422355
    // for details.
    // "十", "壱拾", "拾"
    {"10", 3, {"\xE5\x8D\x81", "\xE5\xA3\xB1\xE6\x8B\xBE", "\xE6\x8B\xBE"},
     {kKanji, kOldKanji, kOldKanji}},
    // "百", "壱百"
    {"100", 2, {"\xE7\x99\xBE", "\xE5\xA3\xB1\xE7\x99\xBE"},
     {kKanji, kOldKanji}},
    // "千", "壱阡", "阡"
    {"1000", 3, {"\xE5\x8D\x83", "\xE5\xA3\xB1\xE9\x98\xA1", "\xE9\x98\xA1"},
     {kKanji, kOldKanji, kOldKanji}},
    {"20", 3,
     // "二十", "弐拾", "廿"
     {"\xE4\xBA\x8C\xE5\x8D\x81", "\xE5\xBC\x90\xE6\x8B\xBE", "\xE5\xBB\xBF"},
     {kKanji, kOldKanji, kOldKanji}},
    {"11111", 4,
     // "1万1111"
     {"1" "\xE4\xB8\x87" "1111",
      // "１万１１１１"
      "\xEF\xBC\x91\xE4\xB8\x87\xEF\xBC\x91\xEF\xBC\x91\xEF\xBC\x91"
      "\xEF\xBC\x91",
      // "一万千百十一"
      "\xE4\xB8\x80\xE4\xB8\x87\xE5\x8D\x83\xE7\x99\xBE\xE5\x8D\x81"
      "\xE4\xB8\x80",
      // "壱萬壱阡壱百壱拾壱"
      "\xE5\xA3\xB1\xE8\x90\xAC\xE5\xA3\xB1\xE9\x98\xA1\xE5\xA3\xB1"
      "\xE7\x99\xBE\xE5\xA3\xB1\xE6\x8B\xBE\xE5\xA3\xB1"},
     {kHalfArabicKanji, kFullArabicKanji, kKanji, kOldKanji}},
    {"12345", 4,
     // "1万2345"
     {"1" "\xE4\xB8\x87" "2345",
      // "１万２３４５"
      "\xEF\xBC\x91\xE4\xB8\x87\xEF\xBC\x92\xEF\xBC\x93\xEF\xBC\x94"
      "\xEF\xBC\x95",
      // "一万二千三百四十五"
      "\xE4\xB8\x80\xE4\xB8\x87\xE4\xBA\x8C\xE5\x8D\x83\xE4\xB8\x89"
      "\xE7\x99\xBE\xE5\x9B\x9B\xE5\x8D\x81\xE4\xBA\x94",
      // "壱萬弐阡参百四拾五"
      "\xE5\xA3\xB1\xE8\x90\xAC\xE5\xBC\x90\xE9\x98\xA1\xE5\x8F\x82"
      "\xE7\x99\xBE\xE5\x9B\x9B\xE6\x8B\xBE\xE4\xBA\x94"},
     {kHalfArabicKanji, kFullArabicKanji, kKanji, kOldKanji}},
    {"100002345", 4,
     // "1億2345"
     {"1" "\xE5\x84\x84" "2345",
      // "１億２３４５"
      "\xEF\xBC\x91\xE5\x84\x84\xEF\xBC\x92\xEF\xBC\x93\xEF\xBC\x94"
      "\xEF\xBC\x95",
      // "一億二千三百四十五"
      "\xE4\xB8\x80\xE5\x84\x84\xE4\xBA\x8C\xE5\x8D\x83\xE4\xB8\x89"
      "\xE7\x99\xBE\xE5\x9B\x9B\xE5\x8D\x81\xE4\xBA\x94",
      // "壱億弐阡参百四拾五"
      "\xE5\xA3\xB1\xE5\x84\x84\xE5\xBC\x90\xE9\x98\xA1\xE5\x8F\x82"
      "\xE7\x99\xBE\xE5\x9B\x9B\xE6\x8B\xBE\xE4\xBA\x94"},
     {kHalfArabicKanji, kFullArabicKanji, kKanji, kOldKanji}},
    {"18446744073709551615", 4,
     // "1844京6744兆737億955万1615"
     {"1844" "\xE4\xBA\xAC" "6744" "\xE5\x85\x86" "737" "\xE5\x84\x84"
      "955" "\xE4\xB8\x87" "1615",
      // "１８４４京６７４４兆７３７億９５５万１６１５"
      "\xEF\xBC\x91\xEF\xBC\x98\xEF\xBC\x94\xEF\xBC\x94\xE4\xBA\xAC"
      "\xEF\xBC\x96\xEF\xBC\x97\xEF\xBC\x94\xEF\xBC\x94\xE5\x85\x86"
      "\xEF\xBC\x97\xEF\xBC\x93\xEF\xBC\x97\xE5\x84\x84\xEF\xBC\x99"
      "\xEF\xBC\x95\xEF\xBC\x95\xE4\xB8\x87\xEF\xBC\x91\xEF\xBC\x96"
      "\xEF\xBC\x91\xEF\xBC\x95",
      // "千八百四十四京六千七百四十四兆七百三十七億九百五十五万千六百十五"
      "\xE5\x8D\x83\xE5\x85\xAB\xE7\x99\xBE\xE5\x9B\x9B\xE5\x8D\x81"
      "\xE5\x9B\x9B\xE4\xBA\xAC\xE5\x85\xAD\xE5\x8D\x83\xE4\xB8\x83"
      "\xE7\x99\xBE\xE5\x9B\x9B\xE5\x8D\x81\xE5\x9B\x9B\xE5\x85\x86"
      "\xE4\xB8\x83\xE7\x99\xBE\xE4\xB8\x89\xE5\x8D\x81\xE4\xB8\x83"
      "\xE5\x84\x84\xE4\xB9\x9D\xE7\x99\xBE\xE4\xBA\x94\xE5\x8D\x81"
      "\xE4\xBA\x94\xE4\xB8\x87\xE5\x8D\x83\xE5\x85\xAD\xE7\x99\xBE"
      "\xE5\x8D\x81\xE4\xBA\x94",
      // "壱阡八百四拾四京六阡七百四拾四兆七百参拾七億九百五拾五萬"
      // "壱阡六百壱拾五"
      "\xE5\xA3\xB1\xE9\x98\xA1\xE5\x85\xAB\xE7\x99\xBE\xE5\x9B\x9B"
      "\xE6\x8B\xBE\xE5\x9B\x9B\xE4\xBA\xAC\xE5\x85\xAD\xE9\x98\xA1"
      "\xE4\xB8\x83\xE7\x99\xBE\xE5\x9B\x9B\xE6\x8B\xBE\xE5\x9B\x9B"
      "\xE5\x85\x86\xE4\xB8\x83\xE7\x99\xBE\xE5\x8F\x82\xE6\x8B\xBE"
      "\xE4\xB8\x83\xE5\x84\x84\xE4\xB9\x9D\xE7\x99\xBE\xE4\xBA\x94"
      "\xE6\x8B\xBE\xE4\xBA\x94\xE8\x90\xAC\xE5\xA3\xB1\xE9\x98\xA1"
      "\xE5\x85\xAD\xE7\x99\xBE\xE5\xA3\xB1\xE6\x8B\xBE\xE4\xBA\x94"},
     {kHalfArabicKanji, kFullArabicKanji, kKanji, kOldKanji}},
  };

  for (size_t i = 0; i < arraysize(kData); ++i) {
    vector<NumberUtil::NumberString> output;
    ASSERT_LE(kData[i].expect_num, kMaxCandsInArabicToKanjiTest);
    EXPECT_TRUE(NumberUtil::ArabicToKanji(kData[i].input, &output));
    ASSERT_EQ(output.size(), kData[i].expect_num)
        << "on conversion of '" << kData[i].input << "'";
    for (int j = 0; j < kData[i].expect_num; ++j) {
      EXPECT_EQ(kData[i].expect_value[j], output[j].value)
          << "input : " << kData[i].input << "\nj : " << j;
      EXPECT_EQ(kData[i].expect_style[j], output[j].style)
          << "input : " << kData[i].input << "\nj : " << j;
    }
  }

  const char *kFailInputs[] = {
    "asf56789", "0.001", "-100", "123456789012345678901"
  };
  for (size_t i = 0; i < arraysize(kFailInputs); ++i) {
    vector<NumberUtil::NumberString> output;
    EXPECT_FALSE(NumberUtil::ArabicToKanji(kFailInputs[i], &output));
    ASSERT_EQ(output.size(), 0) << "input : " << kFailInputs[i];
  }
}

// ArabicToSeparatedArabic TEST
TEST(NumberUtilTest, ArabicToSeparatedArabicTest) {
  string arabic;
  vector<NumberUtil::NumberString> output;

  // Test data expected to succeed
  const char* kSuccess[][3] = {
    // "４"
    {"4", "4", "\xEF\xBC\x94"},
    // "１２３，４５６，７８９"
    {"123456789", "123,456,789", "\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93"
     "\xEF\xBC\x8C\xEF\xBC\x94\xEF\xBC\x95\xEF\xBC\x96\xEF\xBC\x8C"
     "\xEF\xBC\x97\xEF\xBC\x98\xEF\xBC\x99"},
    // "１，２３４，５６７．８９"
    {"1234567.89", "1,234,567.89", "\xEF\xBC\x91\xEF\xBC\x8C\xEF\xBC\x92"
     "\xEF\xBC\x93\xEF\xBC\x94\xEF\xBC\x8C\xEF\xBC\x95\xEF\xBC\x96"
     "\xEF\xBC\x97\xEF\xBC\x8E\xEF\xBC\x98\xEF\xBC\x99"},
    // UINT64_MAX + 1
    {"18446744073709551616", "18,446,744,073,709,551,616", nullptr},
  };

  for (size_t i = 0; i < arraysize(kSuccess); ++i) {
    arabic = kSuccess[i][0];
    output.clear();
    EXPECT_TRUE(NumberUtil::ArabicToSeparatedArabic(arabic, &output));
    ASSERT_EQ(output.size(), 2);
    EXPECT_EQ(kSuccess[i][1], output[0].value);
    EXPECT_EQ(NumberUtil::NumberString::NUMBER_SEPARATED_ARABIC_HALFWIDTH,
              output[0].style);
    if (kSuccess[i][2]) {
      EXPECT_EQ(kSuccess[i][2], output[1].value);
      EXPECT_EQ(NumberUtil::NumberString::NUMBER_SEPARATED_ARABIC_FULLWIDTH,
                output[1].style);
    }
  }

  // Test data expected to fail
  const char* kFail[] = {
    "0123456789", "asdf0123456789", "0.001", "-100",
  };

  for (size_t i = 0; i < arraysize(kFail); ++i) {
    arabic = kFail[i];
    output.clear();
    EXPECT_FALSE(NumberUtil::ArabicToSeparatedArabic(arabic, &output));
    ASSERT_EQ(output.size(), 0);
  }
}

// ArabicToOtherForms
TEST(NumberUtilTest, ArabicToOtherFormsTest) {
  string arabic;
  vector<NumberUtil::NumberString> output;

  arabic = "5";
  output.clear();
  EXPECT_TRUE(NumberUtil::ArabicToOtherForms(arabic, &output));
  ASSERT_EQ(output.size(), 3);

  // "Ⅴ"
  EXPECT_EQ("\xE2\x85\xA4", output[0].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_ROMAN_CAPITAL, output[0].style);

  // "ⅴ"
  EXPECT_EQ("\xE2\x85\xB4", output[1].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_ROMAN_SMALL, output[1].style);

  // "⑤"
  EXPECT_EQ("\xE2\x91\xA4", output[2].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_CIRCLED, output[2].style);

  arabic = "0123456789";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherForms(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "asdf0123456789";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherForms(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "0.001";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherForms(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "-100";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherForms(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "18446744073709551616";  // UINT64_MAX + 1
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherForms(arabic, &output));
}

// ArabicToOtherRadixes
TEST(NumberUtilTest, ArabicToOtherRadixesTest) {
  string arabic;
  vector<NumberUtil::NumberString> output;

  arabic = "1";
  output.clear();
  // "1" is "1" in any radixes.
  EXPECT_FALSE(NumberUtil::ArabicToOtherRadixes(arabic, &output));

  arabic = "2";
  output.clear();
  EXPECT_TRUE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
  ASSERT_EQ(output.size(), 1);

  arabic = "8";
  output.clear();
  EXPECT_TRUE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
  ASSERT_EQ(output.size(), 2);
  EXPECT_EQ("010", output[0].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_OCT, output[0].style);
  EXPECT_EQ("0b1000", output[1].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_BIN, output[1].style);

  arabic = "16";
  output.clear();
  EXPECT_TRUE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
  ASSERT_EQ(output.size(), 3);
  EXPECT_EQ("0x10", output[0].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_HEX, output[0].style);
  EXPECT_EQ("020", output[1].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_OCT, output[1].style);
  EXPECT_EQ("0b10000", output[2].value);
  EXPECT_EQ(NumberUtil::NumberString::NUMBER_BIN, output[2].style);

  arabic = "asdf0123456789";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "0.001";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "-100";
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
  ASSERT_EQ(output.size(), 0);

  arabic = "18446744073709551616";  // UINT64_MAX + 1
  output.clear();
  EXPECT_FALSE(NumberUtil::ArabicToOtherRadixes(arabic, &output));
}

}  // namespace
}  // namespace mozc