#include "util_test.h"

#include "flatbuffers/util.h"
#include "test_assert.h"

namespace flatbuffers {
namespace tests {
namespace {

template <typename T>
void NumericUtilsTestInteger(const char* lower, const char* upper) {
  T x;
  TEST_EQ(flatbuffers::StringToNumber("1q", &x), false);
  TEST_EQ(x, 0);
  TEST_EQ(flatbuffers::StringToNumber(upper, &x), false);
  TEST_EQ(x, flatbuffers::numeric_limits<T>::max());
  TEST_EQ(flatbuffers::StringToNumber(lower, &x), false);
  auto expval = flatbuffers::is_unsigned<T>::value
                    ? flatbuffers::numeric_limits<T>::max()
                    : flatbuffers::numeric_limits<T>::lowest();
  TEST_EQ(x, expval);
}

template <typename T>
void NumericUtilsTestFloat(const char* lower, const char* upper) {
  T f;
  TEST_EQ(flatbuffers::StringToNumber("", &f), false);
  TEST_EQ(flatbuffers::StringToNumber("1q", &f), false);
  TEST_EQ(f, 0);
  TEST_EQ(flatbuffers::StringToNumber(upper, &f), true);
  TEST_EQ(f, +flatbuffers::numeric_limits<T>::infinity());
  TEST_EQ(flatbuffers::StringToNumber(lower, &f), true);
  TEST_EQ(f, -flatbuffers::numeric_limits<T>::infinity());
}
}  // namespace

void NumericUtilsTest() {
  NumericUtilsTestInteger<uint64_t>("-1", "18446744073709551616");
  NumericUtilsTestInteger<uint8_t>("-1", "256");
  NumericUtilsTestInteger<int64_t>("-9223372036854775809",
                                   "9223372036854775808");
  NumericUtilsTestInteger<int8_t>("-129", "128");
  NumericUtilsTestFloat<float>("-3.4029e+38", "+3.4029e+38");
  NumericUtilsTestFloat<float>("-1.7977e+308", "+1.7977e+308");
}

void IsAsciiUtilsTest() {
  char c = -128;
  for (int cnt = 0; cnt < 256; cnt++) {
    auto alpha = (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z'));
    auto dec = (('0' <= c) && (c <= '9'));
    auto hex = (('a' <= c) && (c <= 'f')) || (('A' <= c) && (c <= 'F'));
    TEST_EQ(flatbuffers::is_alpha(c), alpha);
    TEST_EQ(flatbuffers::is_alnum(c), alpha || dec);
    TEST_EQ(flatbuffers::is_digit(c), dec);
    TEST_EQ(flatbuffers::is_xdigit(c), dec || hex);
    c += 1;
  }
}

void UtilConvertCase() {
  {
    struct TestCase {
      std::string input;
      flatbuffers::Case output_case;
      std::string expected_output;
    };

    std::vector<TestCase> cases;

    // Tests for the common cases
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kUpperCamel,
                     "TheQuickBrownFox"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kLowerCamel,
                     "theQuickBrownFox"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kSnake,
                     "the_quick_brown_fox"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kScreamingSnake,
                     "THE_QUICK_BROWN_FOX"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kAllLower,
                     "the_quick_brown_fox"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kAllUpper,
                     "THE_QUICK_BROWN_FOX"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kUnknown,
                     "the_quick_brown_fox"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kKeep,
                     "the_quick_brown_fox"});
    cases.push_back({"the_quick_brown_fox", flatbuffers::Case::kSnake2,
                     "the_quick_brown_fox"});

    // Tests for some snake_cases where the _ is oddly placed or
    // missing.
    cases.push_back({"single", flatbuffers::Case::kUpperCamel, "Single"});
    cases.push_back({"Single", flatbuffers::Case::kUpperCamel, "Single"});
    cases.push_back({"_leading", flatbuffers::Case::kUpperCamel, "_Leading"});
    cases.push_back({"trailing_", flatbuffers::Case::kUpperCamel, "Trailing_"});
    cases.push_back({"double__underscore", flatbuffers::Case::kUpperCamel,
                     "Double_underscore"});
    cases.push_back({"single", flatbuffers::Case::kLowerCamel, "single"});
    cases.push_back({"Single", flatbuffers::Case::kLowerCamel, "single"});
    cases.push_back({"_leading", flatbuffers::Case::kLowerCamel, "_Leading"});
    cases.push_back({"trailing_", flatbuffers::Case::kLowerCamel, "trailing_"});
    cases.push_back({"double__underscore", flatbuffers::Case::kLowerCamel,
                     "double_underscore"});

    // Tests for some output snake_cases
    cases.push_back({"single", flatbuffers::Case::kSnake, "single"});
    cases.push_back({"single", flatbuffers::Case::kScreamingSnake, "SINGLE"});
    cases.push_back(
        {"_leading", flatbuffers::Case::kScreamingSnake, "_LEADING"});
    cases.push_back(
        {"trailing_", flatbuffers::Case::kScreamingSnake, "TRAILING_"});
    cases.push_back({"double__underscore", flatbuffers::Case::kScreamingSnake,
                     "DOUBLE__UNDERSCORE"});

    for (auto& test_case : cases) {
      TEST_EQ(test_case.expected_output,
              flatbuffers::ConvertCase(test_case.input, test_case.output_case));
    }
  }

  // Tests for the non snake_case inputs.
  {
    struct TestCase {
      flatbuffers::Case input_case;
      std::string input;
      flatbuffers::Case output_case;
      std::string expected_output;
    };

    std::vector<TestCase> cases;

    cases.push_back({flatbuffers::Case::kUpperCamel, "TheQuickBrownFox",
                     flatbuffers::Case::kSnake, "the_quick_brown_fox"});
    cases.push_back({flatbuffers::Case::kLowerCamel, "theQuickBrownFox",
                     flatbuffers::Case::kSnake, "the_quick_brown_fox"});
    cases.push_back({flatbuffers::Case::kSnake, "the_quick_brown_fox",
                     flatbuffers::Case::kSnake, "the_quick_brown_fox"});
    cases.push_back({flatbuffers::Case::kScreamingSnake, "THE_QUICK_BROWN_FOX",
                     flatbuffers::Case::kSnake, "THE_QUICK_BROWN_FOX"});
    cases.push_back({flatbuffers::Case::kAllUpper, "SINGLE",
                     flatbuffers::Case::kSnake, "SINGLE"});
    cases.push_back({flatbuffers::Case::kAllLower, "single",
                     flatbuffers::Case::kSnake, "single"});
    cases.push_back({flatbuffers::Case::kUpperCamel, "ABCtest",
                     flatbuffers::Case::kSnake, "abctest"});
    cases.push_back({flatbuffers::Case::kUpperCamel, "tHe_qUiCk_BrOwN_fOx",
                     flatbuffers::Case::kKeep, "tHe_qUiCk_BrOwN_fOx"});
    cases.push_back({flatbuffers::Case::kLowerCamel, "theQuick12345Fox",
                     flatbuffers::Case::kSnake, "the_quick_12345_fox"});
    cases.push_back({flatbuffers::Case::kLowerCamel, "a12b34c45",
                     flatbuffers::Case::kSnake, "a_12b_34c_45"});
    cases.push_back({flatbuffers::Case::kLowerCamel, "a12b34c45",
                     flatbuffers::Case::kSnake2, "a12_b34_c45"});
    cases.push_back({flatbuffers::Case::kUpperCamel, "Int32Stamped",
                     flatbuffers::Case::kSnake, "int_32_stamped"});
    cases.push_back({flatbuffers::Case::kUpperCamel, "101DogsTest",
                     flatbuffers::Case::kSnake, "101_dogs_test"});
    cases.push_back({flatbuffers::Case::kUpperCamel, "Int32Stamped",
                     flatbuffers::Case::kScreamingSnake, "INT_32_STAMPED"});
    cases.push_back({flatbuffers::Case::kUpperCamel, "101DogsTest",
                     flatbuffers::Case::kScreamingSnake, "101_DOGS_TEST"});

    for (auto& test_case : cases) {
      TEST_EQ(test_case.expected_output,
              flatbuffers::ConvertCase(test_case.input, test_case.output_case,
                                       test_case.input_case));
    }
  }
}

}  // namespace tests
}  // namespace flatbuffers