| #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; |
| } |