/**
* 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_mifare_application (void)
{
/* Card publisher part */
MadAid aid = { 0x22, 0x42 };
Mad mad = mad_new (2);
int i;
cut_assert_not_null (mad, cut_message ("mad_new() failed"));
MifareClassicSectorNumber *s_alloc = mifare_application_alloc (mad, aid, 3*3*16);
cut_assert_not_null (s_alloc, cut_message ("mifare_application_alloc() failed"));
MifareClassicSectorNumber *s_found = mifare_application_find (mad, aid);
cut_assert_not_null (s_found, cut_message ("mifare_application_alloc() failed"));
for (i = 0; s_alloc[i]; i++) {
cut_assert_equal_int (s_alloc[i], s_found[i], cut_message ("Allocated and found blocks don't match at position %d", i));
}
cut_assert_equal_int (0, s_alloc[i], cut_message ("Invalid size"));
cut_assert_equal_int (0, s_found[i], cut_message ("Invalid size"));
mifare_application_free (mad, aid);
free (s_alloc);
free (s_found);
s_found = mifare_application_find (mad, aid);
cut_assert_null (s_found, cut_message ("mifare_application_free() failed"));
s_alloc = mifare_application_alloc (mad, aid, 15*16 + 1*16 + 1);
cut_assert_not_null (s_alloc, cut_message ("mifare_application_alloc() failed"));
s_found = mifare_application_find (mad, aid);
cut_assert_not_null (s_found, cut_message ("mifare_application_alloc() failed"));
for (i = 0; s_alloc[i]; i++) {
cut_assert_equal_int (s_alloc[i], s_found[i], cut_message ("Allocated and found blocks don't match at position %d", i));
}
cut_assert_equal_int (0, s_alloc[i], cut_message ("Invalid size"));
cut_assert_equal_int (0, s_found[i], cut_message ("Invalid size"));
mifare_application_free (mad, aid);
free (s_alloc);
free (s_found);
s_found = mifare_application_find (mad, aid);
cut_assert_null (s_found, cut_message ("mifare_application_free() failed"));
mad_free (mad);
}
void
test_args_cost_upper()
{
msgno = -1;
cut_assert_null(password_hash("password", NULL, NULL, 32));
cut_assert_null(password_hash("password", NULL, NULL, 33));
cut_assert_null(password_hash("password", NULL, NULL, 50));
}
void
test_args_cost_lower()
{
msgno = -1;
cut_assert_null(password_hash("password", NULL, NULL, 1));
cut_assert_null(password_hash("password", NULL, NULL, 2));
cut_assert_null(password_hash("password", NULL, NULL, 3));
cut_assert_null(password_hash("password", NULL, NULL, -10));
}
CUT_EXPORT void test_cs_createCSint_SWAP(void)
{
cs_init();
CSint *vint = cs_createCSint(0, -1);
cut_assert_null(vint);
vint = cs_createCSint(1, 0);
cut_assert_null(vint);
vint = cs_createCSint(1, -1);
cut_assert_null(vint);
}
void
test_two_appends(void)
{
List *l = list_append(NULL, INT_TO_POINTER(1));
cut_assert_not_null(l);
cut_assert_null(l->next);
cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);
l = list_append(l, INT_TO_POINTER(2));
cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);
cut_assert_not_null(l->next);
cut_assert_equal_pointer(INT_TO_POINTER(2), l->next->data);
cut_assert_null(l->next->next);
}
void
test_args_salt_short()
{
msgno = -1;
cut_assert_null(password_hash("password", NULL,
"a", BCRYPT_BLOWFISH_COST));
cut_assert_null(password_hash("password", NULL,
"abcdefghij", BCRYPT_BLOWFISH_COST));
cut_assert_null(password_hash("password", NULL,
"abcdefghijklmnopqrst", BCRYPT_BLOWFISH_COST));
cut_assert_null(password_hash("password", NULL,
"abcdefghijklmnopqrstu",
BCRYPT_BLOWFISH_COST));
}
CUT_EXPORT void test_cs_createNamedCSint_SWAP(void)
{
/* this will cause cutter SEGV */
#if 0
cs_init();
CSint *vint = cs_createNamedCSint(0, -1, "dummy");
cut_assert_null(vint);
vint = cs_createNamedCSint(1, 0, "dummy");
cut_assert_null(vint);
vint = cs_createNamedCSint(1, -1, "dummy");
cut_assert_null(vint);
#endif
}
void
test_get_test_suite (void)
{
result = cut_test_result_new(CUT_TEST_RESULT_SUCCESS,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL);
cut_assert_null(cut_test_result_get_test_suite(result));
suite = cut_test_suite_new_empty();
cut_test_result_set_test_suite(result, suite);
cut_assert_equal_pointer(suite, cut_test_result_get_test_suite(result));
cut_test_result_set_test_suite(result, NULL);
cut_assert_null(cut_test_result_get_test_suite(result));
}
void
test_open_with_invalid_max_results(void)
{
default_max_results = -1;
cut_assert_null(open_snip());
default_max_results = 0;
cut_assert_null(open_snip());
default_max_results = 16;
cut_assert_not_null(open_snip());
default_max_results = 17;
cut_assert_null(open_snip());
}
void
test_mb_res_pool_push_and_pop(void)
{
int i;
struct iocb *iocb;
cbpool = mb_res_pool_make(64);
for(i = 0; i < 64; i++) {
iocb = malloc(sizeof(struct iocb));
cut_assert_equal_int(i, cbpool->nr_avail);
cut_assert_equal_int(0, mb_res_pool_push(cbpool, iocb));
}
cut_assert_equal_int(64, cbpool->nr_avail);
iocb = malloc(sizeof(struct iocb));
// pushing into full pool fails
cut_take_memory(iocb);
cut_assert_equal_int(-1, mb_res_pool_push(cbpool, iocb));
for(i = 0; i < 64; i++) {
iocb = mb_res_pool_pop(cbpool);
cut_assert_not_null(iocb);
cut_assert_equal_int(64 - i - 1, cbpool->nr_avail,
cut_message("poped %d iocbs", i+1));
}
// now the pool is empty and pop fails
iocb = mb_res_pool_pop(cbpool);
cut_assert_null(iocb);
}
void
test_open_invalid_chunk_file(void)
{
grn_io *io;
gchar *id_string;
const gchar *expected_error_message =
cut_take_printf("[column][index] file type must be 0x48: <%#04x>", 0);
io = grn_io_create(context, path, 10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
id_string = grn_io_header(io);
strcpy(id_string, "WRONG-ID");
grn_io_close(context, io);
io = grn_io_create(context, cut_take_printf("%s.c", path),
10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
grn_io_close(context, io);
clear_messages();
inverted_index = grn_ii_open(context, path, lexicon);
cut_assert_null(inverted_index);
cut_assert_equal_substring(expected_error_message,
messages()->data,
strlen(expected_error_message));
}
void
test_get_backtrace (void)
{
const GList *actual_backtrace;
CutBacktraceEntry *entry;
result = cut_test_result_new(CUT_TEST_RESULT_SUCCESS,
NULL, NULL, NULL, NULL, NULL,
"user-message",
"system-message",
backtrace);
actual_backtrace = cut_test_result_get_backtrace(result);
cut_assert_not_null(actual_backtrace);
entry = actual_backtrace->data;
cut_assert_equal_string("file name", cut_backtrace_entry_get_file(entry));
cut_assert_equal_uint(999, cut_backtrace_entry_get_line(entry));
cut_assert_equal_string("function name",
cut_backtrace_entry_get_function(entry));
cut_assert_equal_string("info", cut_backtrace_entry_get_info(entry));
g_object_unref(result);
result = cut_test_result_new(CUT_TEST_RESULT_FAILURE,
NULL, NULL, NULL, NULL, NULL,
NULL,
NULL,
NULL);
cut_assert_null(cut_test_result_get_backtrace(result));
}
void
test_create_with_long_path(void)
{
gssize max_size = PATH_MAX - 6;
GString *long_path;
const gchar last_component[] = G_DIR_SEPARATOR_S "index";
long_path = grn_long_path_new(path, max_size - strlen(last_component) - 1);
g_free(path);
g_mkdir_with_parents(long_path->str, 0700);
g_string_append(long_path, last_component);
path = g_string_free(long_path, FALSE);
cut_assert_equal_int(max_size, strlen(path) + 1);
cut_assert_create();
inverted_index_free();
long_path = g_string_new(path);
g_free(path);
g_string_append(long_path, "X");
path = g_string_free(long_path, FALSE);
inverted_index = grn_ii_create(context, path, lexicon, 0);
cut_assert_null(inverted_index);
}
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_fail_to_load (void)
{
loader = loader_new("module", "cannot-load-module." G_MODULE_SUFFIX);
cut_assert_not_null(loader);
test_case = cut_loader_load_test_case(loader);
cut_assert_null(test_case);
}
void
test_open_with_null_lexicon(void)
{
cut_assert_create();
inverted_index_free();
inverted_index = grn_ii_open(context, path, NULL);
cut_assert_null(inverted_index);
}
void
test_prepending_into_null(void)
{
int x = 0;
List *l = list_prepend(NULL, &x);
cut_assert_not_null(l);
cut_assert_null(l->next);
cut_assert_equal_pointer(&x, l->data);
}
CUT_EXPORT void test_cs_createNamedCSint_INT_MAX_TO_INT_MIN(void)
{
/* this will cause cutter SEGV */
#if 0
cs_init();
CSint *vint = cs_createNamedCSint(INT_MAX, INT_MIN, "dummy");
cut_assert_null(vint);
#endif
}
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_invalid(gconstpointer data)
{
unsigned nkeys;
const char *str = gcut_data_get_string(data, "keys");
grn_table_sort_key *keys = grn_table_sort_key_from_str(context, str, strlen(str),
table, &nkeys);
cut_assert_null(keys);
cut_assert_equal_uint(0, nkeys);
}
CUT_EXPORT void test_cs_createNamedCSint_0_TO_INT_MAX_PLUS1(void)
{
/* this will cause cutter SEGV */
#if 0
cs_init();
CSint *vint = cs_createNamedCSint(0, INT_MAX+1, "dummy");
cut_assert_null(vint);
cs_end();
#endif
}
void
test_tlv_rfu (void)
{
uint8_t *data = malloc (0xffff);
cut_assert_not_null (data, cut_message ("Out of memory"));
uint8_t *res = tlv_encode (7, data, 0xffff, NULL);
cut_assert_null (res, cut_message ("Size reserved for future use"));
free (data);
}
CUT_EXPORT void test_cs_createCSintFromDomain(void)
{
cs_init();
CSint *vint = NULL;
int array[] = {1};
vint = cs_createCSintFromDomain(array, 1);
cut_assert_not_null(vint);
#if 0
/* this will cause cutter SEGV */
vint = cs_createCSintFromDomain(NULL, 0);
cut_assert_null(vint);
vint = cs_createCSintFromDomain(array, -1);
cut_assert_null(vint);
vint = cs_createCSintFromDomain(array, 0);
cut_assert_null(vint);
#endif
}
void
test_two_prepends(void)
{
int x, y;
List *l = list_prepend(NULL, &x);
l = list_prepend(l, &y);
cut_assert_not_null(l);
cut_assert_equal_pointer(&y, l->data);
cut_assert_not_null(l->next);
cut_assert_equal_pointer(&x, l->next->data);
cut_assert_null(l->next->next);
}
void
test_get_message_none (void)
{
result = cut_test_result_new(CUT_TEST_RESULT_FAILURE,
NULL, NULL, NULL, NULL, NULL,
NULL,
NULL,
backtrace);
cut_assert_null(cut_test_result_get_message(result));
cut_test_result_set_message(result, "message");
cut_assert_equal_string("message", cut_test_result_get_message(result));
cut_assert_null(cut_test_result_get_user_message(result));
cut_test_result_set_user_message(result, "user message");
cut_assert_equal_string("user message",
cut_test_result_get_user_message(result));
cut_assert_null(cut_test_result_get_system_message(result));
cut_test_result_set_system_message(result, "system message");
cut_assert_equal_string("system message",
cut_test_result_get_system_message(result));
}
void
test_normalizer_accessor(void)
{
grn_obj *normalizer;
cut_assert_open_snip();
cut_assert_null(grn_snip_get_normalizer(&context, snip));
normalizer = grn_ctx_get(&context, "NormalizerNFKC51", -1);
cut_assert_not_null(normalizer);
grn_snip_set_normalizer(&context, snip, normalizer);
cut_assert_equal_pointer(normalizer, grn_snip_get_normalizer(&context, snip));
}
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_fixed_posting_list_doc_intersect (void)
{
PostingList *plist1 = posting_list_new();
posting_list_add(plist1, 0, 0);
posting_list_add(plist1, 0, 1);
posting_list_add(plist1, 1, 3);
posting_list_add(plist1, 3, 4);
posting_list_add(plist1, 200, 4);
posting_list_add(plist1, 100000, 4);
PostingList *plist2 = posting_list_new();
posting_list_add(plist2, 0, 0);
posting_list_add(plist2, 1, 1);
posting_list_add(plist2, 2, 3);
posting_list_add(plist2, 3, 4);
posting_list_add(plist2, 200, 4);
posting_list_add(plist2, 100001, 4);
FixedPostingList *fplist1 = fixed_posting_list_new(plist1);
FixedPostingList *fplist2 = fixed_posting_list_new(plist2);
posting_list_free(plist1, TRUE);
posting_list_free(plist2, TRUE);
FixedPostingList *list = fixed_posting_list_doc_intersect(fplist1, fplist2);
cut_assert_not_null(list);
cut_assert_equal_uint(4, fixed_posting_list_size(list));
fixed_posting_list_free(list);
list = fixed_posting_list_doc_intersect(fplist1, NULL);
cut_assert_null(list);
list = fixed_posting_list_doc_intersect(NULL, fplist2);
cut_assert_null(list);
fixed_posting_list_free(fplist1);
fixed_posting_list_free(fplist2);
}
void
test_llcp_pdu_dispatch(void)
{
struct pdu **pdus = NULL;
pdus = pdu_dispatch(sample_a_pdu);
cut_assert_not_null(pdus, cut_message("pdu_dispatch()"));
cut_assert_not_null(pdus[0], cut_message("First PDU SHALL not be NULL"));
cut_assert_equal_int(0x08, pdus[0]->dsap, cut_message("Wrong DSAP"));
cut_assert_equal_int(PDU_RR, pdus[0]->ptype, cut_message("Wrong PTYPE"));
cut_assert_equal_int(0x02, pdus[0]->ssap, cut_message("Wrong SSAP"));
cut_assert_equal_int(0x00, pdus[0]->ns, cut_message("Wrong N(S)"));
cut_assert_equal_int(0x02, pdus[0]->nr, cut_message("Wrong N(R)"));
cut_assert_equal_int(0, pdus[0]->information_size, cut_message("Wrong information size"));
cut_assert_null(pdus[0]->information, cut_message("Wrong information"));
cut_assert_not_null(pdus[1], cut_message("Second PDU SHALL not be NULL"));
cut_assert_equal_int(0x10, pdus[1]->dsap, cut_message("Wrong DSAP"));
cut_assert_equal_int(PDU_RNR, pdus[1]->ptype, cut_message("Wrong PTYPE"));
cut_assert_equal_int(0x07, pdus[1]->ssap, cut_message("Wrong SSAP"));
cut_assert_equal_int(0x00, pdus[1]->ns, cut_message("Wrong N(S)"));
cut_assert_equal_int(0x03, pdus[1]->nr, cut_message("Wrong N(R)"));
cut_assert_equal_int(0, pdus[1]->information_size, cut_message("Wrong information size"));
cut_assert_null(pdus[1]->information, cut_message("Wrong information"));
cut_assert_null(pdus[2], cut_message("Third PDU SHALL be NULL"));
struct pdu **p = pdus;
while (*p) {
pdu_free(*p);
p++;
}
free(pdus);
}
