v0_1_5/tests/unit-test.cc

#include <cstdlib>
#include <ctime>

#include <marisa_alpha/base.h>
#include <marisa_alpha/popcount.h>
#include <marisa_alpha/rank.h>
#include <marisa_alpha/string.h>
#include <marisa_alpha/key.h>
#include <marisa_alpha/progress.h>
#include <marisa_alpha/range.h>
#include <marisa_alpha/query.h>
#include <marisa_alpha/container.h>
#include <marisa_alpha/cell.h>

#include "assert.h"

namespace {

void TestBase() {
  TEST_START();

  ASSERT(sizeof(marisa_alpha_uint8) == 1);
  ASSERT(sizeof(marisa_alpha_uint16) == 2);
  ASSERT(sizeof(marisa_alpha_uint32) == 4);
  ASSERT(sizeof(marisa_alpha_uint64) == 8);

  ASSERT(MARISA_ALPHA_UINT8_MAX == 0xFFU);
  ASSERT(MARISA_ALPHA_UINT16_MAX == 0xFFFFU);
  ASSERT(MARISA_ALPHA_UINT32_MAX == 0xFFFFFFFFU);
  ASSERT(MARISA_ALPHA_UINT64_MAX == 0xFFFFFFFFFFFFFFFFULL);

  ASSERT(sizeof(marisa_alpha::UInt8) == 1);
  ASSERT(sizeof(marisa_alpha::UInt16) == 2);
  ASSERT(sizeof(marisa_alpha::UInt32) == 4);
  ASSERT(sizeof(marisa_alpha::UInt64) == 8);

  int x = 100, y = 200;
  marisa_alpha::Swap(&x, &y);
  ASSERT(x == 200);
  ASSERT(y == 100);

  EXCEPT(marisa_alpha::Swap(static_cast<int *>(NULL), &y),
      MARISA_ALPHA_PARAM_ERROR);
  EXCEPT(marisa_alpha::Swap(&x, static_cast<int *>(NULL)),
      MARISA_ALPHA_PARAM_ERROR);

  TEST_END();
}

marisa_alpha::UInt32 NaivePopCount(marisa_alpha::UInt32 x) {
  marisa_alpha::UInt32 count = 0;
  while (x) {
    count += x & 1;
    x >>= 1;
  }
  return count;
}

void TestPopCount() {
  TEST_START();

  ASSERT(marisa_alpha::PopCount(0).lo8() == 0);
  ASSERT(marisa_alpha::PopCount(0).lo16() == 0);
  ASSERT(marisa_alpha::PopCount(0).lo24() == 0);
  ASSERT(marisa_alpha::PopCount(0).lo32() == 0);

  ASSERT(marisa_alpha::PopCount(0xFFFFFFFFU).lo8() == 8);
  ASSERT(marisa_alpha::PopCount(0xFFFFFFFFU).lo16() == 16);
  ASSERT(marisa_alpha::PopCount(0xFFFFFFFFU).lo24() == 24);
  ASSERT(marisa_alpha::PopCount(0xFFFFFFFFU).lo32() == 32);

  for (std::size_t i = 0; i < 1024; ++i) {
    marisa_alpha::UInt32 value = std::rand();
    marisa_alpha::PopCount popcount(value);
    ASSERT(popcount.lo8() == NaivePopCount(value & 0xFFU));
    ASSERT(popcount.lo16() == NaivePopCount(value & 0xFFFFU));
    ASSERT(popcount.lo24() == NaivePopCount(value & 0xFFFFFFU));
    ASSERT(popcount.lo32() == NaivePopCount(value));
  }

  TEST_END();
}

void TestRank() {
  TEST_START();

  marisa_alpha::Rank rank;

  ASSERT(rank.abs() == 0);
  ASSERT(rank.rel1() == 0);
  ASSERT(rank.rel2() == 0);
  ASSERT(rank.rel3() == 0);
  ASSERT(rank.rel4() == 0);
  ASSERT(rank.rel5() == 0);
  ASSERT(rank.rel6() == 0);
  ASSERT(rank.rel7() == 0);

  rank.set_abs(0xFFFFFFFFU);
  rank.set_rel1(64);
  rank.set_rel2(128);
  rank.set_rel3(192);
  rank.set_rel4(256);
  rank.set_rel5(320);
  rank.set_rel6(384);
  rank.set_rel7(448);

  ASSERT(rank.abs() == 0xFFFFFFFFU);
  ASSERT(rank.rel1() == 64);
  ASSERT(rank.rel2() == 128);
  ASSERT(rank.rel3() == 192);
  ASSERT(rank.rel4() == 256);
  ASSERT(rank.rel5() == 320);
  ASSERT(rank.rel6() == 384);
  ASSERT(rank.rel7() == 448);

  TEST_END();
}

void TestString() {
  TEST_START();

  marisa_alpha::String str;

  ASSERT(str.ptr() == NULL);
  ASSERT(str.length() == 0);

  marisa_alpha::RString rstr;

  ASSERT(rstr.ptr() == NULL);
  ASSERT(rstr.length() == 0);

  const char *s = "ab";
  str = marisa_alpha::String(s);

  ASSERT(str.ptr() == s);
  ASSERT(str.length() == 2);
  ASSERT(str[0] == s[0]);
  ASSERT(str[1] == s[1]);

  rstr = marisa_alpha::RString(str);
  ASSERT(rstr.ptr() == s);
  ASSERT(rstr.length() == 2);
  ASSERT(rstr[0] == s[1]);
  ASSERT(rstr[1] == s[0]);

  std::string s2 = "xyz";
  str = marisa_alpha::String(s2.c_str(), s2.length());

  ASSERT(str.ptr() == s2.c_str());
  ASSERT(str.length() == 3);
  ASSERT(str[0] == s2[0]);
  ASSERT(str[1] == s2[1]);
  ASSERT(str[2] == s2[2]);

  ASSERT(str.substr(0, 2).length() == 2);
  ASSERT(str.substr(0, 2)[0] == 'x');
  ASSERT(str.substr(0, 2)[1] == 'y');

  rstr = marisa_alpha::RString(str);

  ASSERT(rstr.ptr() == s2.c_str());
  ASSERT(rstr.length() == 3);
  ASSERT(rstr[0] == s2[2]);
  ASSERT(rstr[1] == s2[1]);
  ASSERT(rstr[2] == s2[0]);

  ASSERT(rstr.substr(1, 2).length() == 2);
  ASSERT(rstr.substr(1, 2)[0] == 'y');
  ASSERT(rstr.substr(1, 2)[1] == 'x');

  ASSERT(marisa_alpha::String("abc") == marisa_alpha::String("abc"));
  ASSERT(marisa_alpha::String("abc") != marisa_alpha::String("bcd"));
  ASSERT(marisa_alpha::String("abc") < marisa_alpha::String("bcd"));
  ASSERT(marisa_alpha::String("ab") < marisa_alpha::String("abc"));
  ASSERT(marisa_alpha::String("bcd") > marisa_alpha::String("abc"));
  ASSERT(marisa_alpha::String("abc") > marisa_alpha::String("ab"));

  ASSERT(marisa_alpha::String("abcde").substr(1, 2) ==
      marisa_alpha::String("bc"));

  TEST_END();
}

void TestKey() {
  TEST_START();

  marisa_alpha::Key<marisa_alpha::String> key;

  ASSERT(key.str().length() == 0);
  ASSERT(key.weight() == 0.0);
  ASSERT(key.id() == 0);
  ASSERT(key.terminal() == 0);

  key.set_str(marisa_alpha::String("abc"));
  key.set_weight(1.0);
  key.set_id(2);
  key.set_terminal(3);

  ASSERT(key.str() == marisa_alpha::String("abc"));
  ASSERT(key.weight() == 1.0);
  ASSERT(key.id() == 2);
  ASSERT(key.terminal() == 3);

  marisa_alpha::String str("string");
  marisa_alpha::Key<marisa_alpha::RString> rkey;

  ASSERT(rkey.str().length() == 0);
  ASSERT(rkey.weight() == 0.0);
  ASSERT(rkey.id() == 0);
  ASSERT(rkey.terminal() == 0);

  rkey.set_str(marisa_alpha::RString(str));
  rkey.set_weight(4.0);
  rkey.set_id(5);
  rkey.set_terminal(6);

  ASSERT(rkey.str() == marisa_alpha::RString(str));
  ASSERT(rkey.weight() == 4.0);
  ASSERT(rkey.id() == 5);
  ASSERT(rkey.terminal() == 6);

  TEST_END();
}
void TestProgress() {
  TEST_START();

  {
    marisa_alpha::Progress progress(0);

    ASSERT(progress.is_valid());
    while (!progress.is_last()) {
      ++progress;
    }
    ASSERT(progress.is_last());
    ASSERT(progress.flags() == MARISA_ALPHA_DEFAULT_FLAGS);
    ASSERT(progress.trie_id() == progress.num_tries() - 1);
    ASSERT(progress.total_size() == 0);

    progress.test_total_size(0);
    progress.test_total_size(1);
    EXCEPT(progress.test_total_size(MARISA_ALPHA_UINT32_MAX),
        MARISA_ALPHA_SIZE_ERROR);
    progress.test_total_size(MARISA_ALPHA_UINT32_MAX - 1);
    progress.test_total_size(0);
    EXCEPT(progress.test_total_size(1), MARISA_ALPHA_SIZE_ERROR);

    ASSERT(progress.num_tries() == MARISA_ALPHA_DEFAULT_NUM_TRIES);
    ASSERT(progress.trie() == MARISA_ALPHA_DEFAULT_TRIE);
    ASSERT(progress.tail() == MARISA_ALPHA_DEFAULT_TAIL);
    ASSERT(progress.order() == MARISA_ALPHA_DEFAULT_ORDER);
  }

  {
    marisa_alpha::Progress progress(MARISA_ALPHA_DEFAULT_FLAGS);

    ASSERT(progress.is_valid());
    ASSERT(!progress.is_last());
    ASSERT(progress.num_tries() == MARISA_ALPHA_DEFAULT_NUM_TRIES);
    ASSERT(progress.trie() == MARISA_ALPHA_DEFAULT_TRIE);
    ASSERT(progress.tail() == MARISA_ALPHA_DEFAULT_TAIL);
    ASSERT(progress.order() == MARISA_ALPHA_DEFAULT_ORDER);
  }

  {
    marisa_alpha::Progress progress(255 | MARISA_ALPHA_PREFIX_TRIE
        | MARISA_ALPHA_BINARY_TAIL | MARISA_ALPHA_LABEL_ORDER);

    ASSERT(progress.is_valid());
    ASSERT(!progress.is_last());
    ASSERT(progress.num_tries() == 255);
    ASSERT(progress.trie() == MARISA_ALPHA_PREFIX_TRIE);
    ASSERT(progress.tail() == MARISA_ALPHA_BINARY_TAIL);
    ASSERT(progress.order() == MARISA_ALPHA_LABEL_ORDER);
  }

  {
    marisa_alpha::Progress progress(~MARISA_ALPHA_FLAGS_MASK);

    ASSERT(!progress.is_valid());
  }

  TEST_END();
}

void TestRange() {
  TEST_START();

  marisa_alpha::Range range;

  ASSERT(range.begin() == 0);
  ASSERT(range.end() == 0);
  ASSERT(range.pos() == 0);

  range.set_begin(1);
  range.set_end(2);
  range.set_pos(3);

  ASSERT(range.begin() == 1);
  ASSERT(range.end() == 2);
  ASSERT(range.pos() == 3);

  marisa_alpha::WRange wrange;

  ASSERT(wrange.range().begin() == 0);
  ASSERT(wrange.range().end() == 0);
  ASSERT(wrange.range().pos() == 0);

  ASSERT(wrange.begin() == 0);
  ASSERT(wrange.end() == 0);
  ASSERT(wrange.pos() == 0);
  ASSERT(wrange.weight() == 0.0);

  wrange = marisa_alpha::WRange(range, 4.0);

  ASSERT(wrange.range().begin() == 1);
  ASSERT(wrange.range().end() == 2);
  ASSERT(wrange.range().pos() == 3);

  ASSERT(wrange.begin() == 1);
  ASSERT(wrange.end() == 2);
  ASSERT(wrange.pos() == 3);
  ASSERT(wrange.weight() == 4.0);

  wrange.set_begin(5);
  wrange.set_end(6);
  wrange.set_pos(7);
  wrange.set_weight(8.0);

  ASSERT(wrange.begin() == 5);
  ASSERT(wrange.end() == 6);
  ASSERT(wrange.pos() == 7);
  ASSERT(wrange.weight() == 8.0);

  TEST_END();
}

void TestQuery() {
  TEST_START();

  marisa_alpha::Query query("abc", 3);

  ASSERT(query[0] == 'a');
  ASSERT(!query.ends_at(0));

  ASSERT(query[1] == 'b');
  ASSERT(!query.ends_at(1));

  ASSERT(query[2] == 'c');
  ASSERT(!query.ends_at(2));

  ASSERT(query.ends_at(3));

  std::string str("str");

  query.insert(&str);
  ASSERT(str == "abcstr");

  marisa_alpha::CQuery cquery("xyz");

  ASSERT(cquery[0] == 'x');
  ASSERT(!cquery.ends_at(0));

  ASSERT(cquery[1] == 'y');
  ASSERT(!cquery.ends_at(1));

  ASSERT(cquery[2] == 'z');
  ASSERT(!cquery.ends_at(2));

  ASSERT(cquery.ends_at(3));

  cquery.insert(&str);
  ASSERT(str == "xyzabcstr");

  TEST_END();
}

void TestContainer() {
  TEST_START();

  int array[1024];
  marisa_alpha::Container<int *> array_container(array);

  ASSERT(array_container.is_valid());
  for (int i = 0; i < 1024; ++i) {
    int value = std::rand();
    array_container.insert(i, value);
    ASSERT(array[i] == value);
  }

  marisa_alpha::Container<int *> array_container2(NULL);

  ASSERT(!array_container2.is_valid());

  std::vector<int> vec;
  marisa_alpha::Container<std::vector<int> *> vec_container(&vec);

  ASSERT(vec_container.is_valid());
  for (int i = 0; i < 1024; ++i) {
    int value = std::rand();
    vec_container.insert(i, value);
    ASSERT(vec.back() == value);
    ASSERT(vec[i] == value);
  }
  ASSERT(vec.size() == 1024);

  marisa_alpha::Container<std::vector<int> *> vec_container2(&vec);

  ASSERT(vec_container2.is_valid());
  for (int i = 0; i < 1024; ++i) {
    int value = std::rand();
    vec_container2.insert(i, value);
    ASSERT(vec.back() == value);
    ASSERT(vec[i + 1024] == value);
  }
  ASSERT(vec.size() == 2048);

  marisa_alpha::Container<std::vector<int> *> vec_container3(NULL);
  ASSERT(!vec_container3.is_valid());

  TEST_END();
}

void TestCell() {
  TEST_START();

  marisa_alpha::Cell cell;

  ASSERT(cell.louds_pos() == 0);
  ASSERT(cell.node() == 0);
  ASSERT(cell.key_id() == 0);
  ASSERT(cell.length() == 0);

  cell.set_louds_pos(1);
  cell.set_node(2);
  cell.set_key_id(3);
  cell.set_length(4);

  ASSERT(cell.louds_pos() == 1);
  ASSERT(cell.node() == 2);
  ASSERT(cell.key_id() == 3);
  ASSERT(cell.length() == 4);

  TEST_END();
}

}  // namespace

int main() {
  std::srand((unsigned int)time(NULL));

  TestBase();
  TestPopCount();
  TestRank();
  TestString();
  TestKey();
  TestProgress();
  TestRange();
  TestQuery();
  TestContainer();
  TestCell();

  return 0;
}