void
test_html_mapping(void)
{
const gchar open_tag[] = "<<";
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar keyword[] = "indexing";
default_mapping = (grn_snip_mapping *)-1;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
open_tag, strlen(open_tag), NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip, text, strlen(text),
&n_results, &max_tagged_len));
cut_assert_equal_uint(1, n_results);
cut_assert_equal_uint(113, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string("ngine, & combines the best of n-gram\n"
"<<indexing]] and word <<indexing]] to achieve fast, "
"precise searches. W",
result);
cut_assert_equal_uint(112, result_len);
}
void
test_proper_tag_insertion(gconstpointer data)
{
unsigned int n_results;
unsigned int max_tagged_len;
const gchar keyword[] = "embeddable";
const gchar *expected;
gchar *result;
unsigned int text_len, keyword_len, result_len, expected_len;
default_encoding = GRN_ENC_UTF8;
default_flags = gcut_data_get_int(data, "flags");
text_len = strlen(text);
keyword_len = strlen(keyword);
expected = gcut_data_get_string(data, "expected");
expected_len = strlen(expected);
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, keyword_len,
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip, text, text_len, &n_results,
&max_tagged_len));
cut_assert_equal_uint(1, n_results);
cut_assert_equal_uint(expected_len + 1, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string(expected, result);
cut_assert_equal_uint(expected_len, result_len);
}
void
test_add_cond_with_copy_tag(void)
{
const gchar keyword[] = "Groonga";
unsigned int keyword_len;
const gchar open_tag[] = "<<";
const gchar close_tag[] = ">>";
unsigned int open_tag_len, close_tag_len;
keyword_len = strlen(keyword);
open_tag_len = strlen(open_tag);
close_tag_len = strlen(close_tag);
default_flags = GRN_SNIP_COPY_TAG;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
NULL, 0));
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
NULL, 0,
close_tag, close_tag_len));
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
NULL, 0,
NULL, 0));
}
void
test_exec_composed_decomposed_normalize_utf8(void)
{
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar text[] = "Ⅶ¨abcde";
const gchar keyword[] = "ab";
default_encoding = GRN_ENC_UTF8;
default_flags = GRN_SNIP_NORMALIZE;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip,
text, strlen(text),
&n_results, &max_tagged_len));
cut_assert_equal_uint(1, n_results);
cut_assert_equal_uint(15, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string("Ⅶ¨[[ab]]cde",
result);
cut_assert_equal_uint(14, result_len);
}
void
test_simple_exec_utf8(void)
{
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar keyword[] = "エンジン";
default_encoding = GRN_ENC_UTF8;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip,
text_ja_utf8, strlen(text_ja_utf8),
&n_results, &max_tagged_len));
cut_assert_equal_uint(2, n_results);
cut_assert_equal_uint(105, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string("Groongaは組み込み型の全文検索[[エンジン]]です。"
"DBMSやスクリプト言語処理系",
result);
cut_assert_equal_uint(102, result_len);
grn_test_assert(grn_snip_get_result(&context, snip, 1, result, &result_len));
cut_assert_equal_string("度な転置\n"
"インデックスタイプの[[エンジン]]です。"
"コンパクトな実装ですが、",
result);
cut_assert_equal_uint(104, result_len);
}
void
test_read_write(gconstpointer *data)
{
gint i;
const gchar *key;
grn_ctx *context;
grn_pat *trie;
const gchar *path;
const gchar *value_string;
gint process_number = 0;
const gchar *process_number_string;
void *value;
int added;
grn_id id = GRN_ID_NIL;
grn_rc rc;
i = GPOINTER_TO_INT(data);
process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
if (process_number_string)
process_number = atoi(process_number_string);
key = cut_take_printf("key: %d (%d:%d)", i, process_number, N_THREADS);
rc = grn_ctx_init(contexts[i], GRN_CTX_USE_QL);
cut_set_message("context: %d (%d)", i, process_number);
grn_test_assert(rc);
context = contexts[i];
path = g_getenv(GRN_TEST_ENV_PATRICIA_TRIE_PATH);
cut_assert_not_null(path);
tries[i] = grn_pat_open(context, path);
cut_assert_not_null(tries[i], "patricia trie: %d (%d)", i, process_number);
trie = tries[i];
cut_set_message("lookup - fail: %s (%d:%d)", key, i, process_number);
grn_test_assert_nil(grn_pat_get(context, trie, key, strlen(key), &value));
value_string = cut_take_printf("value: [%s] (%d:%d)", key, i, process_number);
rc = grn_io_lock(context, trie->io, -1);
if (rc != GRN_SUCCESS)
grn_test_assert(rc);
added = 0;
id = grn_pat_add(context, trie, key, strlen(key), &value, &added);
grn_io_unlock(trie->io);
grn_test_assert_not_nil(id);
cut_assert_equal_uint(1, added);
strcpy(value, value_string);
value = NULL;
id = grn_pat_get(context, trie, key, strlen(key), &value);
cut_set_message("lookup - success: %s (%d:%d)", key, i, process_number);
grn_test_assert_not_nil(id);
cut_assert_equal_string(value_string, value);
tries[i] = NULL;
grn_test_assert(grn_pat_close(context, trie));
contexts[i] = NULL;
grn_test_assert(grn_ctx_fin(context));
}
void
test_read_write(gconstpointer *data)
{
gint i, key;
int added;
grn_ctx *context;
grn_hash *hash;
const gchar *path;
const gchar *value_string;
gint process_number = 0;
const gchar *process_number_string;
void *value;
grn_id id = GRN_ID_NIL;
grn_rc rc;
i = GPOINTER_TO_INT(data);
process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
if (process_number_string)
process_number = atoi(process_number_string);
key = i + process_number * N_THREADS;
rc = grn_ctx_init(contexts[i], GRN_CTX_USE_QL);
grn_test_assert(rc, cut_message("context: %d (%d)", i, process_number));
context = contexts[i];
path = g_getenv(GRN_TEST_ENV_HASH_PATH);
cut_assert_not_null(path);
hashes[i] = grn_hash_open(context, path);
cut_assert_not_null(hashes[i],
cut_message("hash: %d (%d)", i, process_number));
hash = hashes[i];
grn_test_assert_nil(
grn_hash_get(context, hash, &key, sizeof(key), &value),
cut_message("lookup - fail: %d (%d:%d)", key, i, process_number));
value_string = cut_take_printf("value: %d (%d:%d)", key, i, process_number);
rc = grn_io_lock(context, hash->io, -1);
if (rc != GRN_SUCCESS)
grn_test_assert(rc);
id = grn_hash_add(context, hash, &key, sizeof(key), &value, &added);
grn_io_unlock(hash->io);
grn_test_assert_not_nil(id);
cut_assert_equal_int(1, added);
strcpy(value, value_string);
value = NULL;
id = grn_hash_get(context, hash, &key, sizeof(key), &value);
grn_test_assert_not_nil(
id,
cut_message("lookup - success: %d (%d:%d)", key, i, process_number));
cut_assert_equal_string(value_string, value);
hashes[i] = NULL;
grn_test_assert(grn_hash_close(context, hash));
contexts[i] = NULL;
grn_test_assert(grn_ctx_fin(context));
}
void
test_simple_exec(void)
{
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar keyword[] = "Groonga";
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip, text, strlen(text),
&n_results, &max_tagged_len));
cut_assert_equal_uint(2, n_results);
cut_assert_equal_uint(105, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string("[[Groonga]] is an embeddable fulltext search engine, "
"which you can use in\n"
"conjunction with various scrip",
result);
cut_assert_equal_uint(104, result_len);
grn_test_assert(grn_snip_get_result(&context, snip, 1, result, &result_len));
cut_assert_equal_string("ting languages and databases. [[Groonga]] is\n"
"an inverted index based engine, & combines "
"the best of n-gr",
result);
cut_assert_equal_uint(104, result_len);
}
void
test_fix_size_set_value_increment(void)
{
gint32 count = 29;
gint32 increment_count = 5;
gint32 retrieved_count;
grn_obj *record_value;
grn_obj *retrieved_record_value;
record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_INT32);
grn_bulk_write(context, record_value, (const char *)&count, sizeof(count));
grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id,
record_value, GRN_OBJ_SET));
grn_obj_close(context, record_value);
record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_INT32);
grn_bulk_write(context, record_value,
(const char *)&increment_count, sizeof(increment_count));
grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id,
record_value, GRN_OBJ_INCR));
grn_obj_close(context, record_value);
retrieved_record_value = grn_obj_get_value(context, count_column,
groonga_bookmark_id, NULL);
memcpy(&retrieved_count,
GRN_BULK_HEAD(retrieved_record_value),
GRN_BULK_VSIZE(retrieved_record_value));
cut_assert_equal_int(count + increment_count, retrieved_count);
grn_obj_close(context, retrieved_record_value);
}
void
test_table_scan(void)
{
grn_obj *cond, *v, *res, textbuf, intbuf;
GRN_TEXT_INIT(&textbuf, 0);
GRN_UINT32_INIT(&intbuf, 0);
prepare_data(&textbuf, &intbuf);
cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, cond, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
grn_expr_append_obj(&context, cond, v);
GRN_TEXT_SETS(&context, &textbuf, "size");
grn_expr_append_const(&context, cond, &textbuf);
grn_expr_append_op(&context, cond, GRN_OP_OBJ_GET_VALUE, 2);
GRN_UINT32_SET(&context, &intbuf, 14);
grn_expr_append_const(&context, cond, &intbuf);
grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2);
grn_expr_compile(&context, cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, 0);
cut_assert_not_null(res);
grn_test_assert(grn_table_scan(&context, docs, cond, res, GRN_SEL_OR));
cut_assert_equal_uint(3, grn_table_size(&context, res));
grn_test_assert(grn_obj_close(&context, res));
grn_test_assert(grn_obj_close(&context, cond));
grn_test_assert(grn_obj_close(&context, &textbuf));
grn_test_assert(grn_obj_close(&context, &intbuf));
}
void
test_html_mapping_escape(void)
{
const gchar close_tag[] = ">&>";
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar keyword[] = "Ruby";
const gchar expected[] =
"y not required.)</li>\n"
" <li>[[Ruby>&> 1.8.1 or later "
/* */"(for [[Ruby>&> binding.)"
/* */"<a class="external" "
/* */"href=";
default_mapping = (grn_snip_mapping *)-1;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, close_tag, strlen(close_tag)));
grn_test_assert(grn_snip_exec(&context, snip, html_text, strlen(html_text),
&n_results, &max_tagged_len));
cut_assert_equal_uint(1, n_results);
cut_assert_equal_uint(strlen(expected) + 1, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string(expected, result);
cut_assert_equal_uint(strlen(expected), result_len);
}
void
test_exec_with_one_length_keyword(void)
{
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar keyword[] = "x";
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip,
text, strlen(text),
&n_results, &max_tagged_len));
cut_assert_equal_uint(2, n_results);
cut_assert_equal_uint(113, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string("Groonga is an embeddable fullte[[x]]t search "
"engine, which you can use in\n"
"conjunction with various scrip",
result);
cut_assert_equal_uint(104, result_len);
grn_test_assert(grn_snip_get_result(&context, snip, 1, result, &result_len));
cut_assert_equal_string("an inverted inde[[x]] based engine, & "
"combines the best of n-gram\n"
"inde[[x]]ing and word inde[[x]]ing to achieve ",
result);
cut_assert_equal_uint(112, result_len);
}
void
test_read_write(gconstpointer *data)
{
gint i;
int added;
grn_ctx *context;
grn_obj *table;
const gchar *path;
const gchar *value_string;
gint process_number = 0;
const gchar *process_number_string;
const gchar table_name[] = "performance-read-write";
grn_obj value;
grn_obj *retrieved_value;
grn_id id;
grn_rc rc;
i = GPOINTER_TO_INT(data);
process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
if (process_number_string)
process_number = atoi(process_number_string);
rc = grn_ctx_init(&contexts[i], GRN_CTX_USE_QL);
grn_test_assert(rc, cut_set_message("context: %d (%d)", i, process_number));
context = &contexts[i];
path = g_getenv(GRN_TEST_ENV_TABLE_PATH);
cut_assert_not_null(path);
tables[i] = grn_table_open(context, table_name, strlen(table_name),
path);
cut_assert_not_null(tables[i],
cut_message("table: %d (%d)", i, process_number));
table = tables[i];
grn_test_assert_nil(grn_table_get(context, table, &i, sizeof(grn_id)),
cut_message("lookup - fail: (%d:%d)", i, process_number));
value_string = cut_take_printf("value: (%d:%d)", i, process_number);
id = grn_table_add(context, table, &i, sizeof(grn_id), &added);
grn_test_assert_not_nil(id);
cut_assert_equal_int(1, added);
GRN_TEXT_INIT(&value, GRN_OBJ_DO_SHALLOW_COPY);
GRN_TEXT_SET_REF(&value, value_string, strlen(value_string));
grn_obj_set_value(context, table, id, &value, GRN_OBJ_SET);
retrieved_value = grn_obj_get_value(context, table, id, NULL);
grn_test_assert_not_nil(
id,
cut_message("lookup - success: (%d:%d)", i, process_number));
GRN_TEXT_PUTC(context, retrieved_value, '\0');
cut_assert_equal_string(value_string, GRN_BULK_HEAD(retrieved_value));
tables[i] = NULL;
grn_test_assert(grn_obj_close(context, table));
// contexts[i] = NULL;
grn_test_assert(grn_ctx_fin(context));
}
void
test_accessor(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, r1, r2;
t1 = grn_table_create(context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL);
cut_assert_not_null(t1);
t2 = grn_table_create(context, "t2", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, NULL);
cut_assert_not_null(t2);
c1 = grn_column_create(context, t1, "c1", 2, NULL,
GRN_OBJ_PERSISTENT, t2);
cut_assert_not_null(c1);
c2 = grn_column_create(context, t2, "c2", 2, NULL,
GRN_OBJ_PERSISTENT, t1);
cut_assert_not_null(c2);
GRN_RECORD_INIT(&r1, 0, grn_obj_id(context, t1));
GRN_RECORD_INIT(&r2, 0, grn_obj_id(context, t2));
for (i = 0; i < NRECORDS; i++) {
grn_id i1, i2;
i1 = grn_table_add(context, t1, NULL, 0, NULL);
i2 = grn_table_add(context, t2, NULL, 0, NULL);
GRN_RECORD_SET(context, &r1, i1);
GRN_RECORD_SET(context, &r2, i2);
grn_obj_set_value(context, c1, i1, &r2, GRN_OBJ_SET);
grn_obj_set_value(context, c2, i2, &r1, GRN_OBJ_SET);
}
{
grn_id id;
uint64_t et;
int nerr = 0;
struct timeval tvb, tve;
grn_obj *a = grn_obj_column(context, t1, "c1.c2.c1", 8);
grn_table_cursor *tc = grn_table_cursor_open(context, t1, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(a);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&r2);
grn_obj_get_value(context, a, id, &r2);
if (GRN_RECORD_VALUE(&r2) != id) {
nerr++;
}
}
gettimeofday(&tve, NULL);
et = (tve.tv_sec - tvb.tv_sec) * 1000000 + (tve.tv_usec - tvb.tv_usec);
// printf("et=%zu\n", et);
cut_assert_equal_uint(0, nerr);
grn_test_assert(grn_table_cursor_close(context, tc));
grn_test_assert(grn_obj_close(context, a));
}
grn_test_assert(grn_obj_close(context, &r1));
grn_test_assert(grn_obj_close(context, &r2));
}
void
test_add_cond_with_invalid_argument(void)
{
unsigned int n_conds = 0, max_n_conds = 32U;
const gchar keyword[] = "Groonga";
unsigned int keyword_len;
const gchar open_tag[] = "<<";
const gchar close_tag[] = ">>";
unsigned int open_tag_len, close_tag_len;
keyword_len = strlen(keyword);
open_tag_len = strlen(open_tag);
close_tag_len = strlen(close_tag);
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
n_conds++;
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, NULL,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, snip,
NULL, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, snip,
keyword, 0,
open_tag, open_tag_len,
close_tag, close_tag_len));
while (n_conds < max_n_conds) {
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len),
cut_message("cond #%d", n_conds));
n_conds++;
}
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len),
cut_message("cond #%d", n_conds));
}
void
test_set_and_get(void)
{
const char *value;
uint32_t value_size;
grn_test_assert(grn_conf_set(&context, "key", -1, "value", -1));
grn_test_assert(grn_conf_get(&context, "key", -1, &value, &value_size));
cut_assert_equal_memory("value", strlen("value"),
value, value_size);
}
void
test_set_value(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:14",
GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, expr, v);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &textbuf, "size");
grn_expr_append_const(&context, expr, &textbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &intbuf, 14);
grn_expr_append_const(&context, expr, &intbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_ASSIGN, 2);
{
grn_id id;
grn_table_cursor *tc;
tc = grn_table_cursor_open(&context, docs, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
}
grn_test_assert(grn_table_cursor_close(&context, tc));
}
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_all(res);
}
const GList *
grn_test_table_collect_string(grn_ctx *context,
grn_obj *table,
const gchar *text_column_name)
{
GList *records = NULL;
grn_table_cursor *cursor;
grn_id id;
grn_obj *text_column;
grn_obj value;
cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_ASCENDING);
grn_test_assert_context(context);
text_column = grn_obj_column(context, table,
text_column_name, strlen(text_column_name));
GRN_TEXT_INIT(&value, 0);
while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
GRN_BULK_REWIND(&value);
grn_obj_get_value(context, text_column, id, &value);
records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&value),
GRN_TEXT_LEN(&value)));
}
grn_obj_unlink(context, &value);
grn_obj_unlink(context, text_column);
gcut_take_list(records, g_free);
grn_test_assert(grn_table_cursor_close(context, cursor));
grn_test_assert_context(context);
return records;
}
void
test_array_set_data(void)
{
grn_obj *table;
grn_id record_id;
gchar value[] = "sample value";
grn_obj *record_value;
grn_obj *retrieved_record_value;
const gchar *dupped_retrieved_record_value;
const gchar *value_type_name = "value_type";
grn_obj *value_type;
value_type = grn_type_create(context,
value_type_name, strlen(value_type_name),
0, sizeof(value));
table = grn_table_create(context, NULL, 0, NULL,
GRN_OBJ_TABLE_NO_KEY,
NULL, value_type);
record_id = grn_table_add(context, table, NULL, 0, NULL);
record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_TEXT);
grn_bulk_write(context, record_value, value, sizeof(value));
grn_test_assert(grn_obj_set_value(context, table, record_id,
record_value, GRN_OBJ_SET));
grn_obj_unlink(context, record_value);
retrieved_record_value = grn_obj_get_value(context, table, record_id, NULL);
dupped_retrieved_record_value =
cut_take_strdup(GRN_BULK_HEAD(retrieved_record_value));
grn_obj_unlink(context, retrieved_record_value);
cut_assert_equal_string(value, dupped_retrieved_record_value);
}
static gboolean
run_test(const gchar **test_case_names, const grn_test_data *data)
{
const gchar *type_name, *table_name;
gchar *path;
grn_test_assert(grn_ctx_init(context, GRN_CTX_USE_QL));
GRN_CTX_SET_ENCODING(context, GRN_ENC_UTF8);
type_name = "name";
type = grn_type_create(context, type_name, strlen(type_name),
GRN_OBJ_KEY_UINT, sizeof(grn_id));
path = g_build_filename(base_dir, "table", NULL);
g_setenv(GRN_TEST_ENV_TABLE_PATH, path, TRUE);
table_name = cut_take_printf("%s: performance-read-write", data->type_name);
g_setenv(GRN_TEST_ENV_TABLE_TYPE, data->type_name, TRUE);
table = grn_table_create(context,
table_name, strlen(table_name),
path, GRN_OBJ_PERSISTENT | data->flags,
type, NULL);
g_free(path);
cut_assert_not_null(table);
return run(test_case_names, data);
}
void
test_score_set(void)
{
grn_obj *v, *res2;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:>0",
GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_all(res);
grn_test_assert(grn_obj_close(&context, cond));
cond = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, res, expr, v);
PARSE(expr, "_score = size",
GRN_EXPR_SYNTAX_SCRIPT|GRN_EXPR_ALLOW_UPDATE);
GRN_TABLE_EACH(&context, res, 0, 0, id, NULL, 0, NULL, {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
});
static void
cast_uint64(guint64 number)
{
grn_obj_reinit(&context, &src, GRN_DB_UINT64, 0);
GRN_UINT64_SET(&context, &src, number);
grn_test_assert(grn_obj_cast(&context, &src, &dest, GRN_FALSE));
}
void
test_add_and_delete(gconstpointer data)
{
const grn_test_data *test_data = data;
guint i;
const guint n_operations = 7500;
if (test_data->set_parameters)
test_data->set_parameters();
cut_assert_create_hash();
ids = g_array_new(TRUE, TRUE, sizeof(grn_id));
for (i = 0; i < n_operations; i++) {
if (grn_test_hash_factory_get_flags(factory) & GRN_OBJ_KEY_VAR_SIZE)
key_size = strlen(test_data->key);
cut_assert_lookup_add(test_data->key);
test_data->increment((grn_test_data *)test_data);
g_array_append_val(ids, id);
}
cut_assert_equal_int(n_operations, GRN_HASH_SIZE(hash));
for (i = 0; i < ids->len; i++) {
grn_id delete_id;
delete_id = g_array_index(ids, grn_id, i);
cut_set_message("i = %d; id = %d", i, delete_id);
grn_test_assert(grn_hash_delete_by_id(context, hash, delete_id, NULL));
}
cut_assert_equal_int(0, GRN_HASH_SIZE(hash));
}
const GList *
grn_test_view_collect_string(grn_ctx *context,
grn_obj *view,
const gchar *text_column_name)
{
GList *records = NULL;
grn_table_cursor *cursor;
grn_obj id, value;
grn_obj *text_column;
cursor = grn_table_cursor_open(context, view, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_ASCENDING);
cut_assert_not_null(cursor);
GRN_TEXT_INIT(&id, 0);
GRN_TEXT_INIT(&value, 0);
text_column = grn_obj_column(context, view,
text_column_name, strlen(text_column_name));
while (grn_table_cursor_next_o(context, cursor, &id) == GRN_SUCCESS) {
GRN_BULK_REWIND(&value);
grn_obj_get_value_o(context, text_column, &id, &value);
records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&value),
GRN_TEXT_LEN(&value)));
}
grn_obj_unlink(context, &id);
grn_obj_unlink(context, &value);
grn_obj_unlink(context, text_column);
gcut_take_list(records, g_free);
grn_test_assert(grn_table_cursor_close(context, cursor));
grn_test_assert_context(context);
return records;
}
void
test_normalize(gconstpointer data)
{
const gchar *utf8_expected, *encoded_expected;
const gchar *utf8_input, *encoded_input;
grn_str *string;
const gchar *normalized_text;
guint normalized_text_len;
int flags;
grn_encoding encoding;
encoding = gcut_data_get_int(data, "encoding");
GRN_CTX_SET_ENCODING(&context, encoding);
flags = GRN_STR_NORMALIZE | GRN_STR_WITH_CHECKS | GRN_STR_WITH_CTYPES;
utf8_input = gcut_data_get_string(data, "input");
encoded_input = convert_encoding(utf8_input, encoding);
string = grn_str_open(&context, encoded_input, strlen(encoded_input), flags);
normalized_text = cut_take_strndup(string->norm, string->norm_blen);
normalized_text_len = string->norm_blen;
grn_test_assert(grn_str_close(&context, string));
utf8_expected = gcut_data_get_string(data, "expected");
encoded_expected = convert_encoding(utf8_expected, encoding);
cut_assert_equal_string(encoded_expected, normalized_text);
cut_assert_equal_int(strlen(encoded_expected), normalized_text_len);
}
void
test_proc_call(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "size:>14",
GRN_EXPR_SYNTAX_QUERY|GRN_EXPR_ALLOW_PRAGMA|GRN_EXPR_ALLOW_COLUMN);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_take_new_list_string("hoge moge moge moge",
"moge hoge fuga fuga",
"moge hoge moge moge moge",
"poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, expr, v);
PARSE(expr, "size = rand(14)", GRN_EXPR_SYNTAX_SCRIPT|GRN_EXPR_ALLOW_UPDATE);
{
grn_id id;
grn_table_cursor *tc;
tc = grn_table_cursor_open(&context, docs, NULL, 0, NULL, 0, 0, -1, 0);
cut_assert_not_null(tc);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_RECORD_SET(&context, v, id);
grn_expr_exec(&context, expr, 0);
}
grn_test_assert(grn_table_cursor_close(&context, tc));
}
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select_none(res);
}
void
test_exec_with_normalize(void)
{
unsigned int n_results;
unsigned int max_tagged_len;
unsigned int result_len;
const gchar keyword[] = "転置インデックス";
default_encoding = GRN_ENC_UTF8;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip,
text_ja_utf8, strlen(text_ja_utf8),
&n_results, &max_tagged_len));
cut_assert_equal_uint(0, n_results);
grn_obj_close(&context, (grn_obj *)snip);
snip = NULL;
default_flags = GRN_SNIP_NORMALIZE;
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip, keyword, strlen(keyword),
NULL, 0, NULL, 0));
grn_test_assert(grn_snip_exec(&context, snip,
text_ja_utf8, strlen(text_ja_utf8),
&n_results, &max_tagged_len));
cut_assert_equal_uint(1, n_results);
cut_assert_equal_uint(105, max_tagged_len);
result = g_new(gchar, max_tagged_len);
grn_test_assert(grn_snip_get_result(&context, snip, 0, result, &result_len));
cut_assert_equal_string("備えた、高速かつ高精度な[[転置\n"
"インデックス]]タイプのエンジンです。コン",
result);
cut_assert_equal_uint(104, result_len);
}
static void
insert_document(const gchar *author_content, const gchar *body_content)
{
uint32_t s = (uint32_t)strlen(body_content);
grn_id docid = grn_table_add(&context, docs, NULL, 0, NULL);
if (author_content) {
GRN_TEXT_SET(&context, &text_buf, author_content, strlen(author_content));
grn_test_assert(grn_obj_set_value(&context, author, docid, &text_buf,
GRN_OBJ_SET));
}
GRN_TEXT_SET(&context, &text_buf, body_content, s);
grn_test_assert(grn_obj_set_value(&context, body, docid, &text_buf,
GRN_OBJ_SET));
GRN_UINT32_SET(&context, &int_buf, s);
grn_test_assert(grn_obj_set_value(&context, size, docid, &int_buf,
GRN_OBJ_SET));
}
static void
insert_and_search(grn_obj *users, grn_obj *items, grn_obj *checks, grn_obj *checked)
{
grn_id user1 = grn_table_add(context, users, NULL, 0, NULL);
grn_id user2 = grn_table_add(context, users, NULL, 0, NULL);
grn_id item = grn_table_add(context, items, NULL, 0, NULL);
grn_obj value, *res;
GRN_TEXT_INIT(&value, 0);
res = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_HASH_KEY, users, 0);
cut_assert_not_null(res);
grn_bulk_write(context, &value, (void *)&item, sizeof(grn_id));
value.header.domain = grn_obj_id(context, items);
grn_test_assert(grn_obj_set_value(context, checks, user1, &value, GRN_OBJ_SET));
grn_test_assert(grn_obj_search(context, checked, &value, res, GRN_OP_OR, NULL));
cut_assert_equal_int(grn_table_size(context, res), 1);
grn_test_assert(grn_obj_set_value(context, checks, user2, &value, GRN_OBJ_SET));
grn_test_assert(grn_obj_search(context, checked, &value, res, GRN_OP_OR, NULL));
cut_assert_equal_int(grn_table_size(context, res), 2);
grn_obj_close(context, &value);
grn_obj_close(context, res);
}
void
test_exec_with_empty_string(void)
{
unsigned int n_results;
unsigned int max_tagged_len;
cut_assert_open_snip();
grn_test_assert(grn_snip_exec(&context, snip, "", 0,
&n_results, &max_tagged_len));
cut_assert_equal_uint(0, n_results);
}
