coding/coding_tests/string_utf8_multilang_tests.cpp - master - githubmirror/omim

coding/coding_tests/string_utf8_multilang_tests.cpp
254 строки7 KB
tatiana-yan
[coding] Add StringUtf8Multilang::RemoveString.
15 июн 2020, 13:07
15 июн 2020, 13:07a0edccb
#include "testing/testing.hpp"

#include "coding/string_utf8_multilang.hpp"

#include "base/control_flow.hpp"

#include "3party/utfcpp/source/utf8.h"

#include <cstddef>
#include <string>
#include <vector>

using namespace std;

namespace
{
struct lang_string
{
  char const * m_lang;
  char const * m_str;
};

lang_string gArr[] = {{"default", "default"},
                      {"en", "abcd"},
                      {"ru", "\xD0\xA0\xD0\xB0\xD1\x88\xD0\xBA\xD0\xB0"},
                      {"be", "\xE2\x82\xAC\xF0\xA4\xAD\xA2"}};

void TestMultilangString(lang_string const * arr, size_t count)
{
  StringUtf8Multilang s;

  for (size_t i = 0; i < count; ++i)
  {
    string src(arr[i].m_str);
    TEST(utf8::is_valid(src.begin(), src.end()), ());

    s.AddString(arr[i].m_lang, src);

    string comp;
    TEST(s.GetString(arr[i].m_lang, comp), ());
    TEST_EQUAL(src, comp, ());
  }

  for (size_t i = 0; i < count; ++i)
  {
    string comp;
    TEST(s.GetString(arr[i].m_lang, comp), ());
    TEST_EQUAL(arr[i].m_str, comp, ());
  }

  string test;
  TEST(!s.GetString("xxx", test), ());
}
}  // namespace

UNIT_TEST(MultilangString_Smoke)
{
  StringUtf8Multilang s;

  TestMultilangString(gArr, ARRAY_SIZE(gArr));
}

UNIT_TEST(MultilangString_ForEach)
{
  StringUtf8Multilang s;
  for (size_t i = 0; i < ARRAY_SIZE(gArr); ++i)
    s.AddString(gArr[i].m_lang, gArr[i].m_str);

  {
    size_t index = 0;
    s.ForEach([&index](char lang, string const & utf8s) {
      TEST_EQUAL(lang, StringUtf8Multilang::GetLangIndex(gArr[index].m_lang), ());
      TEST_EQUAL(utf8s, gArr[index].m_str, ());
      ++index;
    });
    TEST_EQUAL(index, ARRAY_SIZE(gArr), ());
  }

  {
    size_t index = 0;
    vector<string> const expected = {"default", "en", "ru"};
    vector<string> actual;
    s.ForEach([&index, &actual](char lang, string const & utf8s) {
      actual.push_back(gArr[index].m_lang);
      ++index;
      if (index == 3)
        return base::ControlFlow::Break;
      return base::ControlFlow::Continue;
    });
    TEST_EQUAL(index, 3, ());
    TEST_EQUAL(actual, expected, ());
  }
}

UNIT_TEST(MultilangString_Unique)
{
  StringUtf8Multilang s;
  string cmp;

  s.AddString(0, "xxx");
  TEST(s.GetString(0, cmp), ());
  TEST_EQUAL(cmp, "xxx", ());

  s.AddString(1, "yyy");
  TEST(s.GetString(1, cmp), ());
  TEST_EQUAL(cmp, "yyy", ());

  s.AddString(0, "xxxxxx");
  TEST(s.GetString(0, cmp), ());
  TEST_EQUAL(cmp, "xxxxxx", ());
  TEST(s.GetString(1, cmp), ());
  TEST_EQUAL(cmp, "yyy", ());

  s.AddString(0, "x");
  TEST(s.GetString(0, cmp), ());
  TEST_EQUAL(cmp, "x", ());
  TEST(s.GetString(1, cmp), ());
  TEST_EQUAL(cmp, "yyy", ());
}

UNIT_TEST(MultilangString_LangNames)
{
  // It is important to compare the contents of the strings, and not just pointers
  TEST_EQUAL(string("Беларуская"),
             StringUtf8Multilang::GetLangNameByCode(StringUtf8Multilang::GetLangIndex("be")), ());

  auto const & langs = StringUtf8Multilang::GetSupportedLanguages();
  // Using size_t workaround, because our logging/testing macroses do not support passing POD types
  // by value, only by reference. And our constant is a constexpr.
  TEST_LESS_OR_EQUAL(langs.size(), static_cast<size_t>(StringUtf8Multilang::kMaxSupportedLanguages),
                     ());
  auto const international = StringUtf8Multilang::GetLangIndex("int_name");
  TEST_EQUAL(langs[international].m_code, string("int_name"), ());
}

UNIT_TEST(MultilangString_HasString)
{
  StringUtf8Multilang s;
  s.AddString(0, "xxx");
  s.AddString(18, "yyy");
  s.AddString(63, "zzz");

  TEST(s.HasString(0), ());
  TEST(s.HasString(18), ());
  TEST(s.HasString(63), ());

  TEST(!s.HasString(1), ());
  TEST(!s.HasString(32), ());
}

UNIT_TEST(MultilangString_ForEachLanguage)
{
  using Translations = vector<pair<string, string>>;
  StringUtf8Multilang s;
  Translations const scotlandTranslations = {
      {"be", "Шатландыя"},  {"cs", "Skotsko"},   {"cy", "Yr Alban"},  {"da", "Skotland"},
      {"de", "Schottland"}, {"eo", "Skotlando"}, {"es", "Escocia"},   {"eu", "Eskozia"},
      {"fi", "Skotlanti"},  {"fr", "Écosse"},    {"ga", "Albain"},    {"gd", "Alba"},
      {"hr", "Škotska"},    {"ia", "Scotia"},    {"io", "Skotia"},    {"ja", "スコットランド"},
      {"ku", "Skotland"},   {"lfn", "Scotland"}, {"nl", "Schotland"}, {"pl", "Szkocja"},
      {"ru", "Шотландия"},  {"sco", "Scotland"}, {"sk", "Škótsko"},   {"sr", "Шкотска"},
      {"sv", "Skottland"},  {"tok", "Sukosi"},   {"tzl", "Escot"},    {"uk", "Шотландія"},
      {"vo", "Skotän"},     {"zh", "苏格兰"}};

  Translations const usedTranslations = {
      {"be", "Шатландыя"}, {"cs", "Skotsko"}, {"eu", "Eskozia"}, {"zh", "苏格兰"}};

  for (auto const & langAndTranslation : scotlandTranslations)
  {
    s.AddString(langAndTranslation.first, langAndTranslation.second);
  }

  set<string> testAccumulator;
  vector<string> const preferredLanguages = {"cs", "eu", "be", "zh"};
  vector<string> const preferredTranslations = {"Skotsko", "Eskozia", "Шатландыя", "苏格兰"};

  auto const fn = [&testAccumulator, &usedTranslations](int8_t code, string const & name) {
    testAccumulator.insert(name);
    if (usedTranslations.size() > testAccumulator.size())
      return base::ControlFlow::Continue;
    return base::ControlFlow::Break;
  };

  TEST(s.ForEachLanguage(preferredLanguages, fn), ());
  TEST_EQUAL(testAccumulator.size(), preferredTranslations.size(), ());

  for (string const & translation : preferredTranslations)
  {
    TEST(testAccumulator.find(translation) != testAccumulator.end(), ());
  }

  testAccumulator.clear();
  vector<string> const corruptedLanguages = {"Матерный", "Детский", "BirdLanguage"};
  TEST(!s.ForEachLanguage(corruptedLanguages, fn), ());
  TEST_EQUAL(testAccumulator.size(), 0, ());
}

UNIT_TEST(MultilangString_RemoveString)
{
  auto testRemove = [](vector<pair<uint8_t, string>> const & strings,
                       set<uint8_t> const & codesToRemove) {
    StringUtf8Multilang str;
    for (auto const & s : strings)
      str.AddString(s.first, s.second);

    string tmp;
    for (auto const & s : strings)
    {
      TEST(str.HasString(s.first), ());
      TEST(str.GetString(s.first, tmp), ());
      TEST_EQUAL(tmp, s.second, ());
    }

    for (auto c : codesToRemove)
      str.RemoveString(c);

    for (auto const & s : strings)
    {
      if (codesToRemove.find(s.first) == codesToRemove.end())
      {
        TEST(str.HasString(s.first), ());
        TEST(str.GetString(s.first, tmp), ());
        TEST_EQUAL(tmp, s.second, ());
      }
      else
      {
        TEST(!str.HasString(s.first), ());
      }
    }

    // No extra languages or other data damage.
    str.ForEach([&](uint8_t lang, auto const &) {
      TEST(base::FindIf(strings, [&lang](auto const & s) { return s.first == lang; }) !=
               strings.end(),
           ());
      TEST(codesToRemove.find(lang) == codesToRemove.end(), ());
    });
  };

  vector<pair<uint8_t, string>> strings = {{0, "aaa"},
                                           {1, "bbb"},
                                           {2, "ccc"},
                                           {9, "ddd"},
                                           {17, "eee"},
                                           {27, "fff"},
                                           {37, "ggg"}};

  testRemove(strings, {0});
  testRemove(strings, {1});
  testRemove(strings, {9, 27});
  testRemove(strings, {37});
  testRemove(strings, {0, 1, 2, 9, 17, 27, 37});
  testRemove(strings, {39});
}