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); }