void
test_stop_on_data (void)
{
cut_assert_true(milter_server_context_data(context));
cut_assert_equal_uint(1, n_stop_on_data);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_stop_on_end_of_header (void)
{
cut_assert_true(milter_server_context_end_of_header(context));
cut_assert_equal_uint(1, n_stop_on_end_of_header);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_default_packet_buffer_size (void)
{
cut_assert_equal_uint(
0,
milter_manager_configuration_get_default_packet_buffer_size(config));
milter_manager_configuration_set_default_packet_buffer_size(config, 4096);
cut_assert_equal_uint(
4096,
milter_manager_configuration_get_default_packet_buffer_size(config));
}
void
test_max_pending_finished_sessions (void)
{
cut_assert_equal_uint(
0,
milter_manager_configuration_get_max_pending_finished_sessions(config));
milter_manager_configuration_set_max_pending_finished_sessions(config, 29);
cut_assert_equal_uint(
29,
milter_manager_configuration_get_max_pending_finished_sessions(config));
}
void
test_controller_unix_socket_mode (void)
{
cut_assert_equal_uint(
0660,
milter_manager_configuration_get_controller_unix_socket_mode(config));
milter_manager_configuration_set_controller_unix_socket_mode(config, 0600);
cut_assert_equal_uint(
0600,
milter_manager_configuration_get_controller_unix_socket_mode(config));
}
void
test_chunk_size (void)
{
cut_assert_equal_uint(
MILTER_CHUNK_SIZE,
milter_manager_configuration_get_chunk_size(config));
milter_manager_configuration_set_chunk_size(config, 29);
cut_assert_equal_uint(
29,
milter_manager_configuration_get_chunk_size(config));
}
void
test_suspend_time_on_unacceptable (void)
{
cut_assert_equal_uint(
MILTER_CLIENT_DEFAULT_SUSPEND_TIME_ON_UNACCEPTABLE,
milter_manager_configuration_get_suspend_time_on_unacceptable(config));
milter_manager_configuration_set_suspend_time_on_unacceptable(config, 10);
cut_assert_equal_uint(
10,
milter_manager_configuration_get_suspend_time_on_unacceptable(config));
}
void
test_maintenance_interval (void)
{
cut_assert_equal_uint(
10,
milter_manager_configuration_get_maintenance_interval(config));
milter_manager_configuration_set_maintenance_interval(config, 100);
cut_assert_equal_uint(
100,
milter_manager_configuration_get_maintenance_interval(config));
}
void
test_max_file_descriptors (void)
{
cut_assert_equal_uint(
0,
milter_manager_configuration_get_max_file_descriptors(config));
milter_manager_configuration_set_max_file_descriptors(config, 1024);
cut_assert_equal_uint(
1024,
milter_manager_configuration_get_max_file_descriptors(config));
}
void
test_max_connections (void)
{
cut_assert_equal_uint(
MILTER_CLIENT_DEFAULT_MAX_CONNECTIONS,
milter_manager_configuration_get_max_connections(config));
milter_manager_configuration_set_max_connections(config, 10);
cut_assert_equal_uint(
10,
milter_manager_configuration_get_max_connections(config));
}
void
test_connection_check_interval (void)
{
cut_assert_equal_uint(
0,
milter_manager_configuration_get_connection_check_interval(config));
milter_manager_configuration_set_connection_check_interval(config, 5);
cut_assert_equal_uint(
5,
milter_manager_configuration_get_connection_check_interval(config));
}
void
test_n_workers (void)
{
cut_assert_equal_uint(
0,
milter_manager_configuration_get_n_workers(config));
milter_manager_configuration_set_n_workers(config, 5);
cut_assert_equal_uint(
5,
milter_manager_configuration_get_n_workers(config));
}
void
test_stop_on_envelope_from (void)
{
const gchar from[] = "*****@*****.**";
cut_assert_true(milter_server_context_envelope_from(context, from));
cut_assert_equal_uint(1, n_stop_on_envelope_from);
cut_assert_equal_string(from, actual_envelope_from);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_stop_on_helo (void)
{
const gchar fqdn[] = "delian";
cut_assert_true(milter_server_context_helo(context, fqdn));
cut_assert_equal_uint(1, n_stop_on_helo);
cut_assert_equal_string(fqdn, helo_fqdn);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_accessor(void)
{
int i;
grn_obj *t1, *t2, *c1, *c2, buf;
t1 = grn_table_create(&context, "t1", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
cut_assert_not_null(t1);
t2 = grn_table_create(&context, "t2", 2, NULL,
GRN_OBJ_TABLE_NO_KEY|GRN_OBJ_PERSISTENT, NULL, 0);
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_TEXT_INIT(&buf, 0);
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_BULK_REWIND(&buf);
grn_bulk_write(&context, &buf, (char *)&i2, sizeof(grn_id));
grn_obj_set_value(&context, c1, i1, &buf, GRN_OBJ_SET);
grn_obj_set_value(&context, c2, i2, &buf, 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);
cut_assert_not_null(a);
cut_assert_not_null(tc);
gettimeofday(&tvb, NULL);
while ((id = grn_table_cursor_next(&context, tc))) {
GRN_BULK_REWIND(&buf);
grn_obj_get_value(&context, a, id, &buf);
if (GRN_RECORD_VALUE(&buf) != 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);
cut_assert_equal_uint(0, grn_table_cursor_close(&context, tc));
cut_assert_equal_uint(0, grn_obj_close(&context, a));
}
cut_assert_equal_uint(0, grn_obj_close(&context, &buf));
}
void
test_stop_on_envelope_recipient (void)
{
const gchar recipient[] = "*****@*****.**";
cut_assert_true(milter_server_context_envelope_recipient(context,
recipient));
cut_assert_equal_uint(1, n_stop_on_envelope_recipient);
cut_assert_equal_string(recipient, actual_envelope_recipient);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_unix_socket_mode (void)
{
cut_assert_equal_uint(0660,
milter_client_get_default_unix_socket_mode(client));
cut_assert_equal_uint(0660,
milter_client_get_unix_socket_mode(client));
milter_client_set_default_unix_socket_mode(client, 0600);
cut_assert_equal_uint(0600,
milter_client_get_default_unix_socket_mode(client));
cut_assert_equal_uint(0600,
milter_client_get_unix_socket_mode(client));
milter_client_set_unix_socket_mode(client, 0666);
cut_assert_equal_uint(0600,
milter_client_get_default_unix_socket_mode(client));
cut_assert_equal_uint(0666,
milter_client_get_unix_socket_mode(client));
milter_client_set_unix_socket_mode(client, 0);
cut_assert_equal_uint(0600,
milter_client_get_default_unix_socket_mode(client));
cut_assert_equal_uint(0600,
milter_client_get_unix_socket_mode(client));
}
void
test_stop_on_body (void)
{
const gchar body[] = "abcdefg";
cut_assert_true(milter_server_context_body(context,
body, sizeof(body)));
cut_assert_equal_uint(1, n_stop_on_body);
cut_assert_equal_memory(body, sizeof(body), body_chunk, body_chunk_size);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_stop_on_header (void)
{
const gchar name[] = "X-Test-Header";
const gchar value[] = "Test Value";
cut_assert_true(milter_server_context_header(context, name, value));
cut_assert_equal_uint(1, n_stop_on_header);
cut_assert_equal_string(name, actual_header_name);
cut_assert_equal_string(value, actual_header_value);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
void
test_send_message (void)
{
SoupMessage *message;
const gchar *uri;
uri = serve(client);
message = soup_message_new("GET", uri);
cut_assert_equal_uint(0, soupcut_client_get_n_messages(client));
soupcut_client_send_message(client, message);
cut_assert_equal_uint(1, soupcut_client_get_n_messages(client));
gcut_assert_equal_object(message, soupcut_client_get_latest_message(client));
assert_response_equal_body(cut_take_printf("Hello %s", uri), client);
}
void
test_text_to_uint8(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_UINT8, 0);
cast_text("29");
cut_assert_equal_uint(29, GRN_UINT8_VALUE(&dest));
}
void
test_int32_to_uint16(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_UINT16, 0);
cast_int32(2929);
cut_assert_equal_uint(2929, GRN_UINT16_VALUE(&dest));
}
void
test_uint64_to_uint32(void)
{
grn_obj_reinit(&context, &dest, GRN_DB_UINT32, 0);
cast_uint64(29292929);
cut_assert_equal_uint(29292929, GRN_UINT32_VALUE(&dest));
}
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_memcached_replace(void)
{
uint32_t flags;
memcached_return rc;
grn_test_memcached_assert_equal_rc(
MEMCACHED_NOTSTORED,
memcached_replace(memc, "key", 3, "value", 5, 0, 0xdeadbeefU),
cut_message("memcached replace succeeded."));
sleep(1);
grn_test_memcached_assert(
memcached_add(memc, "key", 3, "value", 5, 0, 0xdeadbeefU),
cut_message("memcached add failed."));
grn_test_memcached_assert(
memcached_replace(memc, "key", 3, "new-value", 9, 0, 0xdeadbeefU),
cut_message("memcached replace failed."));
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
grn_test_memcached_assert(rc, cut_message("memcached get failed."));
cut_assert_equal_string("new-value", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
}
void
test_memcached_flush_with_time(void)
{
const int sleep_time = 1;
uint32_t flags;
memcached_return rc;
grn_test_memcached_assert(
memcached_set(memc, "key", 3, "to be flushed", 13, 0, 0xdeadbeefU),
cut_message("memcached set failed."));
memcached_flush(memc, sleep_time);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
grn_test_memcached_assert(rc, cut_message("memcached get failed."));
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);
grn_test_memcached_assert_equal_rc(
MEMCACHED_NOTFOUND, rc,
cut_message("memcached get succeeded."));
}
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));
}
const gchar *
grn_test_send_command(grn_ctx *context, const gchar *command)
{
unsigned int send_id, receive_id;
GString *result;
const gchar **lines;
result = g_string_new(NULL);
lines = cut_take_string_array(g_strsplit(command, "\n", 0));
for (; *lines; lines++) {
gchar *command_result;
unsigned int command_result_length;
int flags = 0;
send_id = grn_ctx_send(context, *lines, strlen(*lines), 0);
receive_id = grn_ctx_recv(context, &command_result, &command_result_length,
&flags);
cut_assert_equal_uint(send_id, receive_id);
g_string_append_len(result, command_result, command_result_length);
grn_test_assert_context(context,
cut_message("<%s>:<%s>", command, result->str));
}
return cut_take_strdup(g_string_free(result, FALSE));
}
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_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);
}
