void
test_mb_read_or_write(void)
{
int i;
double write_ratio;
// always do read
argv[1] = dummy_file;
parse_args(2, argv, &option);
mb_set_option(&option);
cut_assert_equal_int(MB_DO_READ, mb_read_or_write());
// always do write
argv[1] = "-W";
argv[2] = dummy_file;
parse_args(3, argv, &option);
mb_set_option(&option);
cut_assert_equal_int(MB_DO_WRITE, mb_read_or_write());
argv[1] = "-M";
argv[2] = "0.5";
argv[3] = dummy_file;
parse_args(4, argv, &option);
mb_set_option(&option);
write_ratio = 0.0;
for(i = 0; i < 100000; i++){
if (MB_DO_WRITE == mb_read_or_write())
write_ratio += 1.0;
}
write_ratio /= 100000;
cut_assert_equal_double(0.5, 0.001, write_ratio);
argv[1] = "-M";
argv[2] = "0.0";
argv[3] = dummy_file;
parse_args(4, argv, &option);
mb_set_option(&option);
write_ratio = 0.0;
for(i = 0; i < 100000; i++){
if (MB_DO_WRITE == mb_read_or_write())
write_ratio += 1.0;
}
write_ratio /= 100000;
cut_assert_equal_double(0.0, 0.001, write_ratio);
argv[1] = "-M";
argv[2] = "1.0";
argv[3] = dummy_file;
parse_args(4, argv, &option);
mb_set_option(&option);
write_ratio = 0.0;
for(i = 0; i < 100000; i++){
if (MB_DO_WRITE == mb_read_or_write())
write_ratio += 1.0;
}
write_ratio /= 100000;
cut_assert_equal_double(1.0, 0.001, write_ratio);
}
static void
assert_statistics(history_gluon_statistics_t *expected,
history_gluon_statistics_t *actual)
{
cut_assert_equal_int_least64(expected->count, actual->count);
double err = 0.0;
cut_assert_equal_double(expected->min, err, actual->min);
cut_assert_equal_double(expected->max, err, actual->max);
cut_assert_equal_double(expected->sum, err, actual->sum);
cut_assert_equal_double(expected->average, err, actual->average);
cut_assert_equal_double(expected->delta, err, actual->delta);
}
void
test_uint64_to_float(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_FLOAT, 0);
cast_uint64(29);
cut_assert_equal_double(29, 0.1, GRN_FLOAT_VALUE(&dest));
}
void
test_text_to_float(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_FLOAT, 0);
cast_text("29.029");
cut_assert_equal_double(29.029, 0.001, GRN_FLOAT_VALUE(&dest));
}
void
test_start_stop (void)
{
GTimeVal *start_time, *start_time_after_stop;
GTimeVal *end_time;
gdouble elapsed, elapsed_after_stop;
start_time = milter_message_result_get_start_time(result);
cut_assert_equal_int(0, start_time->tv_sec);
cut_assert_equal_int(0, start_time->tv_usec);
end_time = milter_message_result_get_end_time(result);
cut_assert_equal_int(0, end_time->tv_sec);
cut_assert_equal_int(0, end_time->tv_usec);
cut_assert_equal_double(0.0,
0.0001,
milter_message_result_get_elapsed_time(result));
milter_message_result_start(result);
start_time = milter_message_result_get_start_time(result);
cut_assert_operator_int(0, <, start_time->tv_sec);
cut_assert_operator_int(0, <, start_time->tv_usec);
end_time = milter_message_result_get_end_time(result);
cut_assert_equal_int(0, end_time->tv_sec);
cut_assert_equal_int(0, end_time->tv_usec);
elapsed = milter_message_result_get_elapsed_time(result);
cut_assert_equal_double(0.0, 0.0001, elapsed);
g_usleep(1);
milter_message_result_stop(result);
start_time_after_stop = milter_message_result_get_start_time(result);
cut_assert_equal_int(start_time->tv_sec, start_time_after_stop->tv_sec);
cut_assert_equal_int(start_time->tv_usec, start_time_after_stop->tv_usec);
end_time = milter_message_result_get_end_time(result);
cut_assert_operator_int(0, <, end_time->tv_sec);
cut_assert_operator_int(0, <, end_time->tv_usec);
elapsed_after_stop = milter_message_result_get_elapsed_time(result);
cut_assert_operator_double(elapsed, <, elapsed_after_stop);
cut_assert_equal_double(elapsed_after_stop,
0.0001,
milter_message_result_get_elapsed_time(result));
}
void
test_parse_args_rwmix_mode(void)
{
argv[1] = "-M";
argv[2] = "0.5";
argv[3] = dummy_file;
cut_assert_equal_int(0, parse_args(4, argv, &option));
cut_assert_false(option.read);
cut_assert_false(option.write);
cut_assert_equal_double(0.5, 0.001, option.rwmix);
}
static void
check_double_value (GKeyFile *keyfile,
const gchar *group,
const gchar *key,
gdouble expected)
{
GError *error = NULL;
gdouble value;
value = g_key_file_get_double (keyfile, group, key, &error);
check_no_error (error);
cut_assert_equal_double (expected, 0.0, value,
cut_message ("Group %s key %s: "
"expected integer value %e, "
"actual value %e",
group, key, expected, value));
}
void
test_aton(gconstpointer data)
{
const gchar *input, *input_end, *rest;
grn_builtin_type type;
grn_rc rc;
type = gcut_data_get_int(data, "type");
input = gcut_data_get_string(data, "input");
input_end = strchr(input, '\0');
rc = grn_aton(&context, input, input_end, &rest, &buffer);
grn_test_assert(rc);
cut_assert_equal_string(input_end, rest);
cut_assert_equal_int(type, buffer.header.domain);
switch (type) {
case GRN_DB_INT32 :
cut_assert_equal_int(gcut_data_get_int(data, "expected"),
GRN_INT32_VALUE(&buffer));
break;
case GRN_DB_UINT32 :
cut_assert_equal_uint(gcut_data_get_uint(data, "expected"),
GRN_UINT32_VALUE(&buffer));
break;
case GRN_DB_INT64 :
gcut_assert_equal_int64(gcut_data_get_int64(data, "expected"),
GRN_INT64_VALUE(&buffer));
break;
case GRN_DB_UINT64 :
gcut_assert_equal_uint64(gcut_data_get_uint64(data, "expected"),
GRN_UINT64_VALUE(&buffer));
break;
case GRN_DB_FLOAT :
cut_assert_equal_double(gcut_data_get_double(data, "expected"),
0.000001,
GRN_FLOAT_VALUE(&buffer));
break;
default :
cut_error("unknown type: %d", type);
break;
}
}
void
test_parse_args_defaults(void)
{
/* test default values */
argv[1] = dummy_file;
cut_assert_equal_int(0, parse_args(2, argv, &option));
cut_assert_equal_int(1, option.multi);
cut_assert_false(option.noop);
cut_assert_null(option.affinities);
cut_assert_equal_int(60, option.timeout);
cut_assert_true(option.read);
cut_assert_false(option.write);
cut_assert_equal_double(0, 0.001, option.rwmix);
cut_assert_true(option.seq);
cut_assert_false(option.rand);
cut_assert_false(option.direct);
cut_assert_equal_int(64 * KIBI, option.blk_sz);
cut_assert_false(option.verbose);
cut_assert_false(option.aio);
cut_assert_null(option.aio_tracefile);
cut_assert_equal_int(64, option.aio_nr_events);
}
void
test_estimate_size_for_query(void)
{
grn_obj *index_column;
grn_ii *ii;
grn_obj_close(context, db);
db = grn_db_create(context,
cut_build_path(tmp_directory, "estimate.grn", NULL),
NULL);
assert_send_command("table_create Memos TABLE_NO_KEY");
assert_send_command("column_create Memos content COLUMN_SCALAR Text");
assert_send_command("table_create Terms TABLE_PAT_KEY ShortText "
"--default_tokenizer TokenBigramSplitSymbolAlphaDigit "
"--normalizer NormalizerAuto");
assert_send_command("column_create Terms index COLUMN_INDEX|WITH_POSITION "
"Memos content");
assert_send_command("load --table Memos\n"
"["
"[\"content\"],"
"[\"Groonga\"],"
"[\"Rroonga\"],"
"[\"Mroonga\"]"
"]");
index_column = grn_ctx_get(context, "Terms.index", strlen("Terms.index"));
ii = (grn_ii *)index_column;
cut_assert_equal_double(1, DBL_EPSILON,
grn_ii_estimate_size_for_query(context,
ii,
"Groonga",
strlen("Groonga"),
NULL));
}
void
test_new_from_xml (void)
{
GError *error = NULL;
CutTest *test;
const GList *actual_backtrace;
CutBacktraceEntry *entry;
const gchar xml[] =
"<result>\n"
" <test-case>\n"
" <name>stub test case</name>\n"
" </test-case>\n"
" <test>\n"
" <name>stub-error-test</name>\n"
" <description>Error Test</description>\n"
" <option>\n"
" <name>bug</name>\n"
" <value>1234</value>\n"
" </option>\n"
" </test>\n"
" <status>error</status>\n"
" <detail>This test should error</detail>\n"
" <backtrace>\n"
" <entry>\n"
" <file>test-cut-report-xml.c</file>\n"
" <line>31</line>\n"
" <info>stub_error_test()</info>\n"
" </entry>\n"
" <entry>\n"
" <file>test-cut-test-result.c</file>\n"
" <line>29</line>\n"
" <info>test_new_from_xml(): additional info</info>\n"
" </entry>\n"
" </backtrace>\n"
" <elapsed>0.000100</elapsed>\n"
"</result>\n";
result = cut_test_result_new_from_xml(xml, -1, &error);
gcut_assert_error(error);
cut_assert(result);
test = cut_test_result_get_test(result);
cut_assert(test);
cut_assert_equal_string("stub test case",
cut_test_result_get_test_case_name(result));
cut_assert_equal_string("stub-error-test",
cut_test_result_get_test_name(result));
cut_assert_equal_int(CUT_TEST_RESULT_ERROR,
cut_test_result_get_status(result));
cut_assert_equal_double(0.0001, 0.0, cut_test_result_get_elapsed(result));
actual_backtrace = cut_test_result_get_backtrace(result);
cut_assert_not_null(actual_backtrace);
entry = actual_backtrace->data;
cut_assert_equal_string("test-cut-report-xml.c",
cut_backtrace_entry_get_file(entry));
cut_assert_equal_uint(31, cut_backtrace_entry_get_line(entry));
cut_assert_equal_string("stub_error_test()",
cut_backtrace_entry_get_function(entry));
cut_assert_not_null(g_list_next(actual_backtrace));
entry = g_list_next(actual_backtrace)->data;
cut_assert_equal_string("test-cut-test-result.c",
cut_backtrace_entry_get_file(entry));
cut_assert_equal_uint(29, cut_backtrace_entry_get_line(entry));
cut_assert_equal_string("test_new_from_xml()",
cut_backtrace_entry_get_function(entry));
cut_assert_equal_string("additional info",
cut_backtrace_entry_get_info(entry));
cut_assert_equal_string("This test should error",
cut_test_result_get_message(result));
cut_assert_equal_string("1234",
cut_test_get_attribute(test, "bug"));
cut_assert_equal_string("Error Test",
cut_test_get_description(test));
}
void
test_mroonga_index_score(void)
{
grn_obj *t1,*c1,*lc,*ft;
grn_obj buff;
grn_id r1,r2,r3,r4;
const gchar *mrn_dir;
mrn_dir = cut_build_path(tmp_directory, "mrn", NULL);
g_mkdir_with_parents(mrn_dir, 0700);
grn_obj_close(context, db);
db = grn_db_create(context,
cut_build_path(mrn_dir, "mroonga.grn", NULL),
NULL);
cut_assert_not_null(db);
/* actual table */
t1 = grn_table_create(context, "t1", 2,
cut_build_path(mrn_dir, "t1.grn", NULL),
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
/* lexicon table */
lc = grn_table_create(context, "lc", 2,
cut_build_path(mrn_dir, "lc.grn", NULL),
GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_SHORT_TEXT), 0);
cut_assert_not_null(lc);
grn_test_assert(grn_obj_set_info(context, lc, GRN_INFO_DEFAULT_TOKENIZER,
grn_ctx_at(context, GRN_DB_BIGRAM)));
/* actual column */
c1 = grn_column_create(context, t1, "c1", 2,
cut_build_path(mrn_dir, "t1.c1.grn", NULL),
GRN_OBJ_COLUMN_SCALAR|GRN_OBJ_PERSISTENT,
grn_ctx_at(context, GRN_DB_TEXT));
cut_assert_not_null(c1);
/* fulltext index */
ft = grn_column_create(context, lc, "ft", 2,
cut_build_path(mrn_dir, "lc.ft.grn", NULL),
GRN_OBJ_COLUMN_INDEX|GRN_OBJ_PERSISTENT, t1);
cut_assert_not_null(ft);
GRN_TEXT_INIT(&buff,0);
/* link between actual column and fulltext index */
GRN_UINT32_SET(context, &buff, grn_obj_id(context, c1));
grn_obj_set_info(context, ft, GRN_INFO_SOURCE, &buff); /* need to use grn_id */
/* insert row */
r1 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(1,r1);
GRN_TEXT_SETS(context, &buff, "abcde");
grn_test_assert(grn_obj_set_value(context, c1, r1, &buff, GRN_OBJ_SET));
r2 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(2,r2);
GRN_TEXT_SETS(context, &buff, "fghij");
grn_test_assert(grn_obj_set_value(context, c1, r2, &buff, GRN_OBJ_SET));
r3 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(3,r3);
GRN_TEXT_SETS(context, &buff, "11 22 33");
grn_test_assert(grn_obj_set_value(context, c1, r3, &buff, GRN_OBJ_SET));
r4 = grn_table_add(context, t1, NULL, 0, NULL);
cut_assert_equal_int(4,r4);
GRN_TEXT_SETS(context, &buff, "44 22 55");
grn_test_assert(grn_obj_set_value(context, c1, r4, &buff, GRN_OBJ_SET));
/* confirm record are inserted in both column and index */
cut_assert_equal_int(4,grn_table_size(context,t1));
cut_assert_equal_int(23,grn_table_size(context,lc));
/* nlq search */
{
grn_id id, docid;
grn_obj *res;
grn_table_cursor *tc;
grn_obj score, *score_column;
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
GRN_FLOAT_INIT(&score, 0);
GRN_BULK_REWIND(&buff);
GRN_TEXT_SETS(context, &buff, "hij");
grn_obj_search(context, ft, &buff, res, GRN_OP_OR, NULL);
cut_assert_equal_int(1, grn_table_size(context, res));
score_column = grn_obj_column(context, res, "_score", 6);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, -1, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(2, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(5 ,GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("fghij", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_double(1.0, DBL_EPSILON, GRN_FLOAT_VALUE(&score));
}
grn_table_cursor_close(context, tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
/* boolean search */
{
grn_id id, docid;
grn_obj *res;
grn_obj *match_columns, *match_columns_variable;
grn_obj *expression, *expression_variable;
grn_table_cursor *tc;
grn_obj score, *score_column;
const char *match_columns_expression = "c1 * 5";
const char *qstr = "+22 -55";
GRN_EXPR_CREATE_FOR_QUERY(context, t1,
match_columns, match_columns_variable);
grn_expr_parse(context, match_columns,
match_columns_expression,
strlen(match_columns_expression),
NULL, GRN_OP_MATCH, GRN_OP_AND,
GRN_EXPR_SYNTAX_SCRIPT);
GRN_EXPR_CREATE_FOR_QUERY(context, t1, expression, expression_variable);
res = grn_table_create(context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, t1, 0);
grn_test_assert(grn_expr_parse(context, expression,
qstr, strlen(qstr),
match_columns,
GRN_OP_MATCH, GRN_OP_OR,
GRN_EXPR_SYNTAX_QUERY));
grn_table_select(context, t1, expression, res, GRN_OP_OR);
cut_assert_equal_int(1, grn_table_size(context, res));
GRN_FLOAT_INIT(&score, 0);
score_column = grn_obj_column(context, res, "_score", 6);
tc = grn_table_cursor_open(context, res, NULL, 0, NULL, 0, 0, -1, 0);
while ((id = grn_table_cursor_next(context, tc))) {
GRN_BULK_REWIND(&buff);
grn_table_get_key(context, res, id, &docid, sizeof(grn_id));
cut_assert_equal_int(3, docid);
cut_assert_not_null(grn_obj_get_value(context, c1, docid, &buff));
cut_assert_equal_int(8, GRN_TEXT_LEN(&buff));
cut_assert_equal_substring("11 22 33", (char*) GRN_BULK_HEAD(&buff),GRN_TEXT_LEN(&buff));
grn_obj_get_value(context, score_column, id, &score);
cut_assert_equal_double(5, DBL_EPSILON, GRN_FLOAT_VALUE(&score));
}
grn_obj_close(context, expression);
grn_obj_close(context, match_columns);
grn_table_cursor_close(context ,tc);
grn_obj_close(context, score_column);
grn_obj_close(context, res);
}
grn_obj_close(context, &buff);
grn_obj_close(context, ft);
grn_obj_close(context, c1);
grn_obj_close(context, lc);
grn_obj_close(context, t1);
}
