You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
314 lines
6.9 KiB
314 lines
6.9 KiB
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <ctime>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <marisa.h>
|
|
|
|
#include "marisa-assert.h"
|
|
|
|
namespace {
|
|
|
|
void TestTypes() {
|
|
TEST_START();
|
|
|
|
ASSERT(sizeof(marisa_uint8) == 1);
|
|
ASSERT(sizeof(marisa_uint16) == 2);
|
|
ASSERT(sizeof(marisa_uint32) == 4);
|
|
ASSERT(sizeof(marisa_uint64) == 8);
|
|
|
|
ASSERT(MARISA_WORD_SIZE == (sizeof(std::size_t) * 8));
|
|
|
|
ASSERT(MARISA_UINT8_MAX == 0xFFU);
|
|
ASSERT(MARISA_UINT16_MAX == 0xFFFFU);
|
|
ASSERT(MARISA_UINT32_MAX == 0xFFFFFFFFU);
|
|
ASSERT(MARISA_UINT64_MAX == 0xFFFFFFFFFFFFFFFFULL);
|
|
|
|
ASSERT(sizeof(marisa::UInt8) == 1);
|
|
ASSERT(sizeof(marisa::UInt16) == 2);
|
|
ASSERT(sizeof(marisa::UInt32) == 4);
|
|
ASSERT(sizeof(marisa::UInt64) == 8);
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
void TestSwap() {
|
|
TEST_START();
|
|
|
|
int x = 100, y = 200;
|
|
marisa::swap(x, y);
|
|
ASSERT(x == 200);
|
|
ASSERT(y == 100);
|
|
|
|
double a = 1.23, b = 2.34;
|
|
marisa::swap(a, b);
|
|
ASSERT(a == 2.34);
|
|
ASSERT(b == 1.23);
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
void TestException() {
|
|
TEST_START();
|
|
|
|
try {
|
|
MARISA_THROW(MARISA_OK, "Message");
|
|
} catch (const marisa::Exception &ex) {
|
|
ASSERT(std::strcmp(ex.filename(), __FILE__) == 0);
|
|
ASSERT(ex.line() == (__LINE__ - 3));
|
|
ASSERT(ex.error_code() == MARISA_OK);
|
|
ASSERT(std::strstr(ex.error_message(), "Message") != NULL);
|
|
}
|
|
|
|
EXCEPT(MARISA_THROW(MARISA_OK, "OK"), MARISA_OK);
|
|
EXCEPT(MARISA_THROW(MARISA_NULL_ERROR, "NULL"), MARISA_NULL_ERROR);
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
void TestKey() {
|
|
TEST_START();
|
|
|
|
const char * const str = "apple";
|
|
|
|
marisa::Key key;
|
|
|
|
ASSERT(key.ptr() == NULL);
|
|
ASSERT(key.length() == 0);
|
|
|
|
key.set_str(str);
|
|
|
|
ASSERT(key.ptr() == str);
|
|
ASSERT(key.length() == std::strlen(str));
|
|
|
|
key.set_str(str, 4);
|
|
|
|
ASSERT(key.ptr() == str);
|
|
ASSERT(key.length() == 4);
|
|
|
|
key.set_weight(1.0);
|
|
|
|
ASSERT(key.weight() == 1.0);
|
|
|
|
key.set_id(100);
|
|
|
|
ASSERT(key.id() == 100);
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
void TestKeyset() {
|
|
TEST_START();
|
|
|
|
marisa::Keyset keyset;
|
|
|
|
ASSERT(keyset.size() == 0);
|
|
ASSERT(keyset.empty());
|
|
ASSERT(keyset.total_length() == 0);
|
|
|
|
std::vector<std::string> keys;
|
|
keys.push_back("apple");
|
|
keys.push_back("orange");
|
|
keys.push_back("banana");
|
|
|
|
std::size_t total_length = 0;
|
|
for (std::size_t i = 0; i < keys.size(); ++i) {
|
|
keyset.push_back(keys[i].c_str());
|
|
ASSERT(keyset.size() == (i + 1));
|
|
ASSERT(!keyset.empty());
|
|
|
|
total_length += keys[i].length();
|
|
ASSERT(keyset.total_length() == total_length);
|
|
|
|
ASSERT(keyset[i].length() == keys[i].length());
|
|
ASSERT(std::memcmp(keyset[i].ptr(), keys[i].c_str(),
|
|
keyset[i].length()) == 0);
|
|
ASSERT(keyset[i].weight() == 1.0);
|
|
}
|
|
|
|
keyset.clear();
|
|
|
|
marisa::Key key;
|
|
|
|
key.set_str("123");
|
|
keyset.push_back(key);
|
|
ASSERT(keyset[0].length() == 3);
|
|
ASSERT(std::memcmp(keyset[0].ptr(), "123", 3) == 0);
|
|
|
|
key.set_str("456");
|
|
keyset.push_back(key, '\0');
|
|
ASSERT(keyset[1].length() == 3);
|
|
ASSERT(std::memcmp(keyset[1].ptr(), "456", 3) == 0);
|
|
ASSERT(std::strcmp(keyset[1].ptr(), "456") == 0);
|
|
|
|
key.set_str("789");
|
|
keyset.push_back(key, '0');
|
|
ASSERT(keyset[2].length() == 3);
|
|
ASSERT(std::memcmp(keyset[2].ptr(), "789", 3) == 0);
|
|
ASSERT(std::memcmp(keyset[2].ptr(), "7890", 4) == 0);
|
|
|
|
ASSERT(keyset.size() == 3);
|
|
|
|
keyset.clear();
|
|
|
|
ASSERT(keyset.size() == 0);
|
|
ASSERT(keyset.total_length() == 0);
|
|
|
|
keys.resize(1000);
|
|
std::vector<float> weights(keys.size());
|
|
|
|
total_length = 0;
|
|
for (std::size_t i = 0; i < keys.size(); ++i) {
|
|
keys[i].resize(std::rand() % (marisa::Keyset::EXTRA_BLOCK_SIZE * 2));
|
|
for (std::size_t j = 0; j < keys[i].length(); ++j) {
|
|
keys[i][j] = (char)(std::rand() & 0xFF);
|
|
}
|
|
double weight = 100.0 * static_cast<double>(std::rand()) /
|
|
static_cast<double>(RAND_MAX);
|
|
weights[i] = static_cast<float>(weight);
|
|
|
|
keyset.push_back(keys[i].c_str(), keys[i].length(), weights[i]);
|
|
total_length += keys[i].length();
|
|
ASSERT(keyset.total_length() == total_length);
|
|
}
|
|
|
|
ASSERT(keyset.size() == keys.size());
|
|
for (std::size_t i = 0; i < keys.size(); ++i) {
|
|
ASSERT(keyset[i].length() == keys[i].length());
|
|
ASSERT(std::memcmp(keyset[i].ptr(), keys[i].c_str(),
|
|
keyset[i].length()) == 0);
|
|
ASSERT(keyset[i].weight() == weights[i]);
|
|
}
|
|
|
|
keyset.reset();
|
|
|
|
ASSERT(keyset.size() == 0);
|
|
ASSERT(keyset.total_length() == 0);
|
|
|
|
total_length = 0;
|
|
for (std::size_t i = 0; i < keys.size(); ++i) {
|
|
keys[i].resize(std::rand() % (marisa::Keyset::EXTRA_BLOCK_SIZE * 2));
|
|
for (std::size_t j = 0; j < keys[i].length(); ++j) {
|
|
keys[i][j] = (char)(std::rand() & 0xFF);
|
|
}
|
|
double weight = 100.0 * static_cast<double>(std::rand()) /
|
|
static_cast<double>(RAND_MAX);
|
|
weights[i] = static_cast<float>(weight);
|
|
|
|
keyset.push_back(keys[i].c_str(), keys[i].length(), weights[i]);
|
|
total_length += keys[i].length();
|
|
ASSERT(keyset.total_length() == total_length);
|
|
}
|
|
|
|
ASSERT(keyset.size() == keys.size());
|
|
for (std::size_t i = 0; i < keys.size(); ++i) {
|
|
ASSERT(keyset[i].length() == keys[i].length());
|
|
ASSERT(std::memcmp(keyset[i].ptr(), keys[i].c_str(),
|
|
keyset[i].length()) == 0);
|
|
ASSERT(keyset[i].weight() == weights[i]);
|
|
}
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
void TestQuery() {
|
|
TEST_START();
|
|
|
|
marisa::Query query;
|
|
|
|
ASSERT(query.ptr() == NULL);
|
|
ASSERT(query.length() == 0);
|
|
ASSERT(query.id() == 0);
|
|
|
|
const char *str = "apple";
|
|
query.set_str(str);
|
|
|
|
ASSERT(query.ptr() == str);
|
|
ASSERT(query.length() == std::strlen(str));
|
|
|
|
query.set_str(str, 3);
|
|
|
|
ASSERT(query.ptr() == str);
|
|
ASSERT(query.length() == 3);
|
|
|
|
query.set_id(100);
|
|
|
|
ASSERT(query.id() == 100);
|
|
|
|
query.clear();
|
|
|
|
ASSERT(query.ptr() == NULL);
|
|
ASSERT(query.length() == 0);
|
|
ASSERT(query.id() == 0);
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
void TestAgent() {
|
|
TEST_START();
|
|
|
|
marisa::Agent agent;
|
|
|
|
ASSERT(agent.query().ptr() == NULL);
|
|
ASSERT(agent.query().length() == 0);
|
|
ASSERT(agent.query().id() == 0);
|
|
|
|
ASSERT(agent.key().ptr() == NULL);
|
|
ASSERT(agent.key().length() == 0);
|
|
|
|
ASSERT(!agent.has_state());
|
|
|
|
const char *query_str = "query";
|
|
const char *key_str = "key";
|
|
|
|
agent.set_query(query_str);
|
|
agent.set_query(123);
|
|
agent.set_key(key_str);
|
|
agent.set_key(234);
|
|
|
|
ASSERT(agent.query().ptr() == query_str);
|
|
ASSERT(agent.query().length() == std::strlen(query_str));
|
|
ASSERT(agent.query().id() == 123);
|
|
|
|
ASSERT(agent.key().ptr() == key_str);
|
|
ASSERT(agent.key().length() == std::strlen(key_str));
|
|
ASSERT(agent.key().id() == 234);
|
|
|
|
agent.init_state();
|
|
|
|
ASSERT(agent.has_state());
|
|
|
|
EXCEPT(agent.init_state(), MARISA_STATE_ERROR);
|
|
|
|
agent.clear();
|
|
|
|
ASSERT(agent.query().ptr() == NULL);
|
|
ASSERT(agent.query().length() == 0);
|
|
ASSERT(agent.query().id() == 0);
|
|
|
|
ASSERT(agent.key().ptr() == NULL);
|
|
ASSERT(agent.key().length() == 0);
|
|
|
|
ASSERT(!agent.has_state());
|
|
|
|
TEST_END();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main() try {
|
|
TestTypes();
|
|
TestSwap();
|
|
TestException();
|
|
TestKey();
|
|
TestKeyset();
|
|
TestQuery();
|
|
TestAgent();
|
|
|
|
return 0;
|
|
} catch (const marisa::Exception &ex) {
|
|
std::cerr << ex.what() << std::endl;
|
|
throw;
|
|
}
|