void
test_pat_integer_index_with_query(void)
{
assert_send_commands("table_create Ages TABLE_PAT_KEY Int32\n"
"column_create Ages site_index COLUMN_INDEX Sites age");
assert_send_commands("load --table Sites\n"
"[\n"
"[\"_key\", \"score\", \"age\", \"description\"],\n"
"[\"mroonga.github.com\", 100, 2, "
"\"fast fulltext search on MySQL\"],\n"
"[\"groonga.rubyforge.org\", 100, 1, "
"\"Ruby bindings for groonga\"]\n"
"]");
cut_assert_equal_string(
"[[[5],"
"[[\"age\",\"Int32\"],[\"_key\",\"ShortText\"]],"
"[1,\"groonga.rubyforge.org\"],"
"[2,\"groonga.org\"],"
"[2,\"mroonga.github.com\"],"
"[5,\"qwik.jp/senna/FrontPageJ.html\"],"
"[11,\"2ch.net\"]]]",
send_command("select Sites "
"--sortby \"age\" "
"--output_columns \"age, _key\" "
"--match_columns \"description\" "
"--query \"fulltext OR BBS OR groonga\""));
}
/**
* readline() 関数テスト
*
* @return なし
*/
void
test_readline(void)
{
char nolf_data[] = "test"; /* 改行なし文字列 */
/* 正常系 */
result = exec_readline(test_data, sizeof(test_data));
/* 改行削除 */
if (test_data[strlen(test_data) - 1] == '\n')
test_data[strlen(test_data) - 1] = '\0';
cut_assert_equal_string(test_data, (char *)result);
memfree((void **)&result, NULL);
/* 異常系 */
/* 改行ない場合 */
result = exec_readline(nolf_data, sizeof(nolf_data));
dbglog("result=%s", result);
cut_assert_null((char *)result);
/* ファイルポインタがNULLの場合 */
result = _readline((FILE *)NULL);
cut_assert_null((char *)result);
}
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_drilldown(void)
{
gdouble yurakucho_latitude = 35.67487;
gdouble yurakucho_longitude = 139.76352;
gint distance = 10 * 1000;
cut_assert_equal_string(
"[[[23],"
"[[\"name\",\"ShortText\"],[\"_score\",\"Int32\"]],"
"[\"たい焼き鉄次 大丸東京店\",810],"
"[\"たいやき神田達磨 八重洲店\",970],"
"[\"にしみや 甘味処\",1056],"
"[\"築地 さのきや\",1186],"
"[\"しげ田\",1530],"
"[\"柳屋 たい焼き\",2179],"
"[\"尾長屋 錦糸町店\",5007],"
"[\"根津のたいやき\",5036],"
"[\"横浜 くりこ庵 浅草店\",5098],"
"[\"たい焼き写楽\",5457]],"
"[[7],"
"[[\"_key\",\"ShortText\"],"
"[\"name\",\"ShortText\"],"
"[\"_nsubrecs\",\"Int32\"]],"
"[\"おでん\",\"\",1],"
"[\"たいやき\",\"\",23],"
"[\"カレー\",\"\",1],"
"[\"マグロ\",\"\",1],"
"[\"和菓子\",\"\",1],"
"[\"天然\",\"\",4],"
"[\"白\",\"\",1]],"
"[[2],"
"[[\"_key\",\"ShortText\"],"
"[\"name\",\"ShortText\"],"
"[\"_nsubrecs\",\"Int32\"]],"
"[\"category0001\",\"和食\",1],"
"[\"category0003\",\"おやつ\",1]],"
"[[3],"
"[[\"_key\",\"ShortText\"],"
"[\"name\",\"ShortText\"],"
"[\"_nsubrecs\",\"Int32\"]],"
"[\"area0002\",\"東京都中央区\",3],"
"[\"area0005\",\"東京都文京区\",1],"
"[\"area0013\",\"東京都渋谷区\",1]]"
"]",
send_command(
cut_take_printf(
"select Shops "
"--sortby '+_score, +name' "
"--output_columns 'name, _score' "
"--filter 'geo_in_circle(location, \"%s\", %d) && tags @ \"たいやき\"' "
"--scorer '_score=geo_distance2(location, \"%s\")' "
"--drilldown 'tags categories area' "
"--drilldown_output_columns '_key, name, _nsubrecs' "
"--drilldown_sortby '_key'",
grn_test_location_string(yurakucho_latitude, yurakucho_longitude),
distance,
grn_test_location_string(yurakucho_latitude, yurakucho_longitude))));
}
void
test_mail_transaction_shelf (void)
{
cut_assert_equal_string(
NULL,
milter_client_context_get_mail_transaction_shelf_value(context, "test"));
milter_client_context_set_mail_transaction_shelf_value(context,
"test",
"test value");
cut_assert_equal_string(
"test value",
milter_client_context_get_mail_transaction_shelf_value(context, "test"));
milter_client_context_clear_mail_transaction_shelf(context);
cut_assert_equal_string(
NULL,
milter_client_context_get_mail_transaction_shelf_value(context, "test"));
}
void
test_get_string (void)
{
cut_trace(test_load());
cut_assert_equal_string("/XXX/SENDMAIL",
mz_config_get_string(config, "sendmail_path"));
}
void
test_run (void)
{
GError *error = NULL;
process = gcut_process_new(cuttest_echo_path, "XXX", NULL);
setup_process(process);
gcut_assert_equal_pid(0, gcut_process_get_pid(process));
gcut_process_run(process, &error);
gcut_assert_error(error);
gcut_assert_not_equal_pid(0, gcut_process_get_pid(process));
wait_exited();
cut_assert_equal_string("XXX\n", output_string->str);
cut_assert_equal_string("", error_string->str);
}
void
test_invalid_order_option (void)
{
cut_assert(run_cutter("--test-case-order=XXX"));
cut_assert_exit_failure();
cut_assert_equal_string("Invalid test case order value: XXX" LINE_FEED_CODE,
stdout_string);
}
void
test_invalid_verbose_option (void)
{
cut_assert(run_cutter("--verbose=XXX"));
cut_assert_exit_failure();
cut_assert_equal_string("Invalid verbose level name: XXX" LINE_FEED_CODE,
stdout_string);
}
void
test_invalid_color_option (void)
{
cut_assert(run_cutter("--color=XXX"));
cut_assert_exit_failure();
cut_assert_equal_string("Invalid color value: XXX" LINE_FEED_CODE,
stdout_string);
}
void
test_get_content_disposition_with_line_feed (void)
{
char *type = NULL, *filename = NULL, *charset = NULL;
const char *content;
unsigned int length;
cut_take_string(type);
cut_take_string(filename);
content = mz_test_utils_load_data("attachment_content_disposition_with_line_feed", &length);
cut_assert_not_null(content);
cut_assert_true(mz_utils_get_content_disposition(content, length, &type, &charset, &filename));
cut_assert_equal_string("attachment", type);
cut_assert_equal_string("t.png", filename);
}
void
test_time_float(void)
{
assert_send_command("table_create Logs TABLE_NO_KEY");
assert_send_command("column_create Logs time_stamp COLUMN_SCALAR Time");
cut_assert_equal_string("1",
send_command("load --table Logs\n"
"[{\"time_stamp\": 1295851581.41798}]"));
cut_assert_equal_string("[[[1],"
"["
"[\"_id\",\"UInt32\"],"
"[\"time_stamp\",\"Time\"]"
"],"
"[1,1295851581.41798]"
"]]",
send_command("select Logs"));
}
void
test_package_options (void)
{
const gchar *actual_package_options;
actual_package_options =
milter_manager_configuration_get_package_options(config);
cut_assert_equal_string(MILTER_MANAGER_PACKAGE_OPTIONS,
actual_package_options);
milter_manager_configuration_set_package_options(config, "prefix=/etc");
actual_package_options =
milter_manager_configuration_get_package_options(config);
cut_assert_equal_string("prefix=/etc",
actual_package_options);
}
void
test_package_platform (void)
{
const gchar *actual_package_platform;
actual_package_platform =
milter_manager_configuration_get_package_platform(config);
cut_assert_equal_string(MILTER_MANAGER_PACKAGE_PLATFORM,
actual_package_platform);
milter_manager_configuration_set_package_platform(config, "new-platform");
actual_package_platform =
milter_manager_configuration_get_package_platform(config);
cut_assert_equal_string("new-platform",
actual_package_platform);
}
void test_mrn_index_table_name_gen()
{
char buf[64], buf2[64];
const char *arg = "./db/users";
mrn_table_name_gen(arg, buf);
cut_assert_equal_string("users-name",
mrn_index_table_name_gen(buf, "name", buf2));
}
void
test_translate(const void *data)
{
const TranslateTestData *test_data = data;
cut_assert_equal_string(test_data->translated,
translate(test_data->input));
}
void
test_invalid_option (void)
{
cut_assert(run_cutter("--XXXX"));
cut_assert_exit_failure();
cut_assert_equal_string("Unknown option --XXXX" LINE_FEED_CODE,
stdout_string);
}
void
test_null(gconstpointer data)
{
assert_send_command("table_create Students TABLE_HASH_KEY ShortText");
assert_send_command("column_create Students nick COLUMN_SCALAR ShortText");
assert_send_command("column_create Students scores COLUMN_VECTOR Int32");
cut_assert_equal_string("1",
send_command("load --table Students\n"
"[{\"_key\": \"Daijiro MORI\", "
"\"nick\": \"morita\", "
"\"scores\": [5, 5, 5]}]"));
cut_assert_equal_string("1",
send_command(gcut_data_get_string(data, "load")));
cut_assert_equal_string(gcut_data_get_string(data, "expected"),
send_command("select Students"));
}
static void
cut_assert_new_from_xml_error_helper(const gchar *expected, const gchar *xml)
{
result = cut_test_result_new_from_xml(xml, -1, &error);
cut_assert_null(result);
cut_assert_not_null(error);
cut_assert_equal_string(expected, error->message);
}
void
test_invalid_char(void)
{
GList *log = NULL;
assert_send_command("table_create Users TABLE_HASH_KEY ShortText");
assert_send_command("column_create Users name COLUMN_SCALAR ShortText");
assert_send_command("column_create Users desc COLUMN_SCALAR ShortText");
grn_collect_logger_clear_messages(logger);
assert_send_command("load --table Users --input_type json\n"
"{\"name\": \"groonga\" @ \"desc\" \"search engine\"}\n"
"");
log = g_list_next(grn_collect_logger_get_messages(logger));
cut_assert_equal_string("ignored invalid char('@') at", g_list_nth_data(log, 0));
cut_assert_equal_string("{\"name\": \"groonga\" @", g_list_nth_data(log, 1));
cut_assert_equal_string(" ^", g_list_nth_data(log, 2));
}
void
test_vector_int32(void)
{
assert_send_command("table_create Students TABLE_HASH_KEY ShortText");
assert_send_command("column_create Students scores COLUMN_VECTOR Int32");
cut_assert_equal_string("1",
send_command("load --table Students\n"
"[{\"_key\": \"Daijiro MORI\", "
"\"scores\": [5, 5, 5]}]"));
cut_assert_equal_string("[[[1],"
"[[\"_id\",\"UInt32\"],"
"[\"_key\",\"ShortText\"],"
"[\"scores\",\"Int32\"]],"
"[1,\"Daijiro MORI\",[5,5,5]]]]",
send_command("select Students"));
}
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_corrupt_jagged_array(void)
{
const gchar *text_65bytes =
"65bytes text "
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const gchar *text_129bytes =
"129bytes text "
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
assert_send_command("table_create Sites TABLE_NO_KEY");
assert_send_command("column_create Sites description COLUMN_SCALAR ShortText");
cut_assert_equal_string(
"1",
send_command(cut_take_printf("load --table Sites\n"
"[[\"description\"],\n"
"[\"%s\"]\n"
"]",
text_129bytes)));
assert_send_command("delete Sites --id 1");
cut_assert_equal_string(
"3",
send_command(cut_take_printf("load --table Sites\n"
"[[\"description\"],\n"
"[\"%s\"],\n"
"[\"%s\"],\n"
"[\"%s\"]"
"]",
text_65bytes,
text_65bytes,
text_129bytes)));
cut_assert_equal_string(
cut_take_printf("[[[3],"
"[[\"_id\",\"UInt32\"],"
"[\"description\",\"ShortText\"]],"
"[2,\"%s\"],"
"[3,\"%s\"],"
"[4,\"%s\"]]]",
text_65bytes,
text_65bytes,
text_129bytes),
send_command("select Sites"));
}
void
test_set_messages_empty (void)
{
result = cut_test_result_new(CUT_TEST_RESULT_FAILURE,
NULL, NULL, NULL, NULL, NULL,
"user message",
"system message",
backtrace);
cut_assert_equal_string("user message\nsystem message",
cut_test_result_get_message(result));
cut_test_result_set_user_message(result, "");
cut_assert_equal_string(NULL,
cut_test_result_get_user_message(result));
cut_assert_equal_string("system message",
cut_test_result_get_system_message(result));
cut_assert_equal_string("system message",
cut_test_result_get_message(result));
cut_test_result_set_system_message(result, "");
cut_assert_equal_string(NULL,
cut_test_result_get_user_message(result));
cut_assert_equal_string(NULL,
cut_test_result_get_system_message(result));
cut_assert_equal_string(NULL,
cut_test_result_get_message(result));
}
/**
* test_server_loop() 関数テスト
*
* @return なし
*/
void
test_server_loop(void)
{
pid_t cpid = 0; /* 子プロセスID */
pid_t w = 0; /* wait戻り値 */
int status = 0; /* wait引数 */
int retval = 0; /* 戻り値 */
int count = 1; /* ループカウント */
if (set_port_string(port) < 0)
cut_error("set_port_string");
ssock = server_sock();
cpid = fork();
if (cpid < 0) {
cut_error("fork(%d)", errno);
return;
}
if (cpid == 0) {
dbglog("child");
count = 2;
g_sig_handled = 1;
while (count--)
server_loop(ssock);
exit(EXIT_SUCCESS);
} else {
dbglog("parent: cpid=%d", (int)cpid);
csock = inet_sock_client();
if (csock < 0)
return;
/* 送信 */
retval = send_client(csock, expr, sizeof(expr));
if (retval < 0) {
cut_error("send_client: csock=%d(%d)", csock, errno);
return;
}
/* 受信 */
retval = recv_client(csock, readbuf);
if (retval < 0) {
cut_error("recv_client: csock=%d(%d)", csock, errno);
return;
}
cut_assert_equal_string((char *)expected, (char *)readbuf);
w = wait(&status);
if (w < 0)
cut_notify("wait(%d)", errno);
dbglog("w=%d", (int)w);
}
}
void
test_set_string (void)
{
cut_trace(test_load());
cut_assert_null(mz_config_get_string(config, "new_value"));
mz_config_set_string(config, "new_value", "12345678X");
cut_assert_equal_string("12345678X",
mz_config_get_string(config, "new_value"));
}
void
test_get_content_disposition_mime_encoded_filename (void)
{
char *type = NULL, *filename = NULL, *charset = NULL;
const char *content;
unsigned int length;
cut_take_string(type);
cut_take_string(filename);
content = mz_test_utils_load_data("attachment_filename_is_mime_encoded", &length);
cut_assert_not_null(content);
cut_assert_true(mz_utils_get_content_disposition(content, length, &type, &charset, &filename));
cut_assert_equal_string("attachment", type);
cut_assert_equal_string("iso-2022-jp", charset);
cut_assert_equal_string("\x1B\x24\x42\x46\x7C\x4B\x5C\x38\x6C\x1B\x28\x42\x2e\x74\x78\x74", /* 日本語.txt */
filename);
}
void
test_expire_cache_on_recreate(void)
{
const gchar *path;
path = cut_build_path(tmp_directory, "database.groonga", NULL);
database = grn_db_create(context, path, NULL);
assert_send_command("table_create Sites 0 ShortText");
assert_send_command("load '[[\"_key\"],[\"groonga.org\"]]' Sites");
cut_assert_equal_string("[[[1],[[\"_key\",\"ShortText\"]],[\"groonga.org\"]]]",
send_command("select Sites --output_columns _key"));
assert_send_command("table_remove Sites");
grn_obj_remove(context, database);
database = grn_db_create(context, path, NULL);
assert_send_command("table_create Sites 0 ShortText");
cut_assert_equal_string("[[[0],[[\"_key\",\"ShortText\"]]]]",
send_command("select Sites --output_columns _key"));
}
void
test_set_diff (void)
{
const gchar diff[] =
" A\n"
"- B\n"
"+ b\n"
" C";
result = cut_test_result_new_empty();
cut_test_result_set_diff(result, diff);
cut_test_result_set_expected(result, "a\nb\nc");
cut_assert_equal_string(diff, cut_test_result_get_diff(result));
cut_assert_equal_string(NULL, cut_test_result_get_folded_diff(result));
cut_test_result_set_actual(result, "a\nB\nc");
cut_assert_equal_string(diff, cut_test_result_get_diff(result));
cut_assert_equal_string(NULL, cut_test_result_get_folded_diff(result));
}
void
test_format_reply (gconstpointer data)
{
const ReplyTestData *test_data = data;
gcut_assert_error(set_reply(test_data->code,
test_data->extended_code,
test_data->message));
cut_assert_equal_string(test_data->expected_formatted_reply, format_reply());
}
