void
test_memcached_flush_with_time(void)
{
const int sleep_time = 1;
uint32_t flags;
memcached_return rc;
rc = memcached_set(memc, "key", 3, "to be flushed", 13, 0, 0xdeadbeefU);
cut_set_message("memcached set failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
memcached_flush(memc, sleep_time);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
cut_set_message("memcached get failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
cut_assert_equal_string("to be flushed", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
sleep(sleep_time + 1);
val2 = memcached_get(memc, "key", 3, &val2_len, &flags, &rc);
cut_set_message("memcached get succeeded.");
cut_assert_equal_int(MEMCACHED_NOTFOUND, rc);
}
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_memcached_replace(void)
{
uint32_t flags;
memcached_return rc;
rc = memcached_replace(memc, "key", 3, "value", 5, 0, 0xdeadbeefU);
cut_set_message("memcached replace succeeded.");
/* TODO: fix rc after libmemcached fix */
cut_assert_equal_int(MEMCACHED_PROTOCOL_ERROR, rc);
sleep(1);
rc = memcached_add(memc, "key", 3, "value", 5, 0, 0xdeadbeefU);
cut_set_message("memcached add failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
rc = memcached_replace(memc, "key", 3, "new-value", 9, 0, 0xdeadbeefU);
cut_set_message("memcached replace failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
cut_set_message("memcached get failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
cut_assert_equal_string("new-value", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
}
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);
cut_set_message("context: %d (%d)", i, process_number);
grn_test_assert(rc);
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], "hash: %d (%d)", i, process_number);
hash = hashes[i];
cut_set_message("lookup - fail: %d (%d:%d)", key, i, process_number);
grn_test_assert_nil(grn_hash_get(context, hash, &key, sizeof(key), &value));
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);
cut_set_message("lookup - success: %d (%d:%d)", key, i, process_number);
grn_test_assert_not_nil(id);
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_set_and_get(void)
{
uint32_t flags;
memcached_return rc;
rc = memcached_set(memc, "key", 3, "value", 5, 0, 0xdeadbeefU);
cut_set_message("memcached set failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
cut_set_message("memcached get failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
cut_assert_equal_string("value", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
}
void
test_memcached_flush(void)
{
uint32_t flags;
memcached_return rc;
rc = memcached_set(memc, "key", 3, "to be flushed", 13, 0, 0xdeadbeefU);
cut_set_message("memcached set failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
memcached_flush(memc, 0);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
cut_set_message("memcached get succeeded.");
cut_assert_equal_int(MEMCACHED_NOTFOUND, rc);
}
void
test_attachment_save (void)
{
GList *attachments, *node;
document = load_document ("attachment.pdf");
cut_assert_true (poppler_document_has_attachments (document));
attachments = poppler_document_get_attachments (document);
gcut_take_list (attachments, attachment_unref);
for (node = attachments; node; node = g_list_next (node))
{
PopplerAttachment *attachment = node->data;
const gchar *filename;
gchar *contents;
const gchar *expected_contents;
GError *error = NULL;
filename = cut_take_string (g_build_filename (tmp_dir,
attachment->name,
NULL));
poppler_attachment_save (attachment, filename, &error);
gcut_assert_error (error);
g_file_get_contents (filename, &contents, NULL, &error);
gcut_assert_error (error);
expected_contents = cut_get_fixture_data_string (attachment->name, NULL);
cut_set_message ("%s", attachment->name);
cut_assert_equal_string_with_free (expected_contents, contents);
}
}
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));
}
void
cut_setup(void)
{
GError *error = NULL;
memcached_return rc;
tmp_directory = g_build_filename(grn_test_get_base_dir(), "tmp", NULL);
cut_remove_path(tmp_directory, NULL);
if (g_mkdir_with_parents(tmp_directory, 0700) == -1) {
cut_assert_errno();
}
egg = gcut_egg_new(GROONGA, "-s",
"-p", GROONGA_TEST_PORT,
cut_take_printf("%s%s%s",
tmp_directory,
G_DIR_SEPARATOR_S,
"memcached.db"),
NULL);
gcut_egg_hatch(egg, &error);
gcut_assert_error(error);
sleep(1); /* wait for groonga daemon */
memc = memcached_create(NULL);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
servers = memcached_servers_parse("localhost:" GROONGA_TEST_PORT);
rc = memcached_server_push(memc, servers);
cut_set_message("memcached server connect failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
memcached_flush(memc, 0); /* flush immediately for debug daemon */
}
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_card_suit_new_from_string(void)
{
cut_set_message("文字列からスーツを作成する。");
cut_assert_true(card_suit_new_from_string("SPADE")==SPADE);
cut_assert_true(card_suit_new_from_string("HEART")==HEART);
cut_assert_true(card_suit_new_from_string("DIAMOND")==DIAMOND);
cut_assert_true(card_suit_new_from_string("CLUB")==CLUB);
}
void
test_memcached_cas(void)
{
memcached_return rc;
const char *key = "caskey";
size_t key_len = strlen(key);
char* keys[2] = { (char *)key, NULL };
size_t key_lens[2] = { key_len, 0 };
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
rc = memcached_set(memc, key, key_len, "cas test", 8, 0, 0xdeadbeefU);
cut_set_message("memcached set failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
{
uint64_t cas;
memcached_result_st *results;
memcached_result_st results_obj;
results = memcached_result_create(memc, &results_obj);
rc = memcached_mget(memc, keys, key_lens, 1);
cut_set_message("memcached mget failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
results = memcached_fetch_result(memc, &results_obj, &rc);
cas = memcached_result_cas(results);
cut_set_message("memcached cas value is non-zero.");
cut_assert_operator_int(cas, !=, 0);
rc = memcached_cas(memc, key, key_len, "cas changed", 12, 0, 0, cas);
cut_set_message("memcached cas failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
rc = memcached_cas(memc, key, key_len, "cas changed", 12, 0, 0, cas);
cut_set_message("memcached cas value is same.");
/* TODO: fix rc after libmemcached fix */
cut_assert_equal_int(MEMCACHED_PROTOCOL_ERROR, rc);
/* cut_assert_equal_int(MEMCACHED_DATA_EXISTS, rc); */
memcached_result_free(&results_obj);
}
}
void
test_card_to_string(void)
{
cut_set_message("カードを文字列にする");
{
Card sa = card_new(SPADE,ACE);
cut_assert(strcmp(card_to_string(sa), "SA")==0);
}
}
static void
add_groonga_bookmark(void)
{
gchar key[] = "groonga";
groonga_bookmark_id = grn_table_add(&context, bookmarks,
&key, strlen(key), NULL);
grn_test_assert_context(&context);
cut_set_message("%s", cut_take_string(grn_collect_logger_to_string(logger)));
grn_test_assert_not_nil(groonga_bookmark_id);
}
void
test_card_no_new_from_string(void)
{
cut_set_message("番号から数値への変換のテスト");
cut_assert(card_no_new_from_string("1")==ACE);
cut_assert(card_no_new_from_string("13")==KING);
cut_assert(card_no_new_from_string("12")==QUEEN);
cut_assert(card_no_new_from_string("11")==JACK);
cut_assert(card_no_new_from_string("10")==10);
}
void
test_card_new(void)
{
cut_set_message("スーツと番号からカードを作成");
{
Card sa = card_new(SPADE,ACE);
cut_assert(card_suit(sa)==SPADE);
cut_assert(card_no(sa)==ACE);
}
}
void
test_set_and_get_with_expire(void)
{
uint32_t flags;
memcached_return rc;
const int timeout = 1;
rc = memcached_set(memc, "key", 1, "value", 5, timeout, 0xdeadbeefU);
cut_set_message("memcached set with expiration failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
val1 = memcached_get(memc, "key", 1, &val1_len, &flags, &rc);
cut_set_message("memcached get with expiration failed.");
cut_assert_equal_int(MEMCACHED_SUCCESS, rc);
cut_assert_equal_string("value", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
sleep(timeout + 1);
val2 = memcached_get(memc, "key", 1, &val2_len, &flags, &rc);
cut_set_message("memcached get with expiration error.");
cut_assert_equal_int(MEMCACHED_NOTFOUND, rc);
}
static void
add_count_column_to_bookmarks_table (void)
{
const gchar count_column_name[] = "count";
count_column = grn_column_create(&context,
bookmarks,
count_column_name,
strlen(count_column_name),
NULL, 0,
LOOKUP("<int>"));
grn_test_assert_context(&context);
cut_set_message("%s", cut_take_string(grn_collect_logger_to_string(logger)));
cut_assert_not_null(count_column);
}
static void
create_bookmarks_table(void)
{
const gchar bookmarks_table_name[] = "bookmarks";
bookmarks = grn_table_create(&context,
bookmarks_table_name,
strlen(bookmarks_table_name),
NULL,
GRN_OBJ_TABLE_HASH_KEY,
LOOKUP("<shorttext>"),
1024);
grn_test_assert_context(&context);
cut_set_message("%s", cut_take_string(grn_collect_logger_to_string(logger)));
cut_assert_not_null(bookmarks);
}
void
grn_test_assert_context_helper (grn_ctx *context, const gchar *expression)
{
if (!context) {
cut_set_message("context should not NULL");
cut_assert_null_helper(context, expression);
} else if (context->rc == GRN_SUCCESS) {
cut_test_pass();
} else {
cut_test_fail(cut_take_printf("<(%s)->rc> != <GRN_SUCCESS>\n"
"expected: <%s> is <%s>\n"
"%s:%d: %s(): %s",
expression,
grn_rc_to_string(context->rc),
grn_rc_to_string(GRN_SUCCESS),
context->errfile, context->errline,
context->errfunc, context->errbuf));
}
}
void
test_crud(void)
{
cut_assert_create();
add_data(1, 1, "API.JA");
add_data(2, 1, "CHECKINSTALL.JA");
add_data(3, 1, "FUTUREWORKS.JA");
add_data(4, 1, "INSTALL.JA");
gcut_assert_equal_list_string(gcut_take_new_list_string("1", "2", "3", NULL),
retrieve_record_ids("検索"));
remove_data(1, 1, "API.JA");
gcut_assert_equal_list_string(gcut_take_new_list_string("2", "3", NULL),
retrieve_record_ids("検索"));
update_data(3, 1, "FUTUREWORKS.JA", "Makefile.am");
gcut_assert_equal_list_string(gcut_take_new_list_string("2", NULL),
retrieve_record_ids("検索"));
remove_data(2, 1, "CHECKINSTALL.JA");
add_data(3, 2, "FUTUREWORKS.JA");
gcut_assert_equal_list_string(gcut_take_new_list_string("3", NULL),
retrieve_record_ids("検索"));
update_data(4, 1, "INSTALL.JA", "README.JA");
gcut_assert_equal_list_string(gcut_take_new_list_string("3", "4", NULL),
retrieve_record_ids("検索"));
remove_data(4, 1, "README.JA");
gcut_assert_equal_list_string(gcut_take_new_list_string("3", NULL),
retrieve_record_ids("検索"));
remove_data(3, 2, "FUTUREWORKS.JA");
cut_set_message("this assertion is wrong?");
gcut_assert_equal_list_string(NULL, retrieve_record_ids("検索"));
}
void
grn_test_assert_error_helper (grn_rc expected_rc, const gchar *expected_message,
grn_ctx *context, const gchar *expression)
{
if (!context) {
cut_set_message("context should not NULL");
cut_assert_null_helper(context, expression);
} else if (context->rc == expected_rc &&
cut_equal_string(expected_message, context->errbuf)) {
cut_test_pass();
} else {
cut_test_fail(cut_take_printf("<%s>\n"
"expected: <%s>(%s)\n"
" actual: <%s>(%s)\n"
"%s:%d: %s():",
expression,
expected_message,
grn_rc_to_string(expected_rc),
context->errbuf,
grn_rc_to_string(context->rc),
context->errfile, context->errline,
context->errfunc));
}
}