void test_launch_error (gconstpointer data) { const gchar *packet; gsize packet_size; GString *output; const gchar *command; const gchar *user_name; const gchar *expected_error_message; command = gcut_data_get_string(data, "command"); user_name = gcut_data_get_string(data, "user-name"); expected_error_message = gcut_data_get_string(data, "expected-error-message"); milter_manager_launch_command_encoder_encode_launch(command_encoder, &packet, &packet_size, command, user_name); cut_trace(write_packet(packet, packet_size)); pump_all_events(); milter_manager_reply_encoder_encode_error(reply_encoder, &packet, &packet_size, expected_error_message); output = gcut_string_io_channel_get_string(output_channel); cut_assert_equal_memory(packet, packet_size, output->str, output->len); }
void test_error_stream (void) { GError *error = NULL; GInputStream *stream; char buffer[4096]; gsize bytes_read; process = gcut_process_new(cuttest_echo_path, "-e", "XXX", NULL); stream = gcut_process_get_error_stream(process); cut_assert_not_null(stream); gcut_process_run(process, &error); gcut_assert_error(error); wait_exited(); g_input_stream_read_all(stream, buffer, sizeof(buffer), &bytes_read, NULL, &error); gcut_assert_error(error); cut_assert_equal_memory("XXX\n", 4, buffer, bytes_read); }
void test_llcp_pdu_aggregate(void) { struct pdu *pdu; struct pdu *pdus[] = { sample_i_pdu, NULL }; pdu = pdu_aggregate(pdus); cut_assert_not_null(pdu, cut_message("pdu_aggregate()")); uint8_t buffer[BUFSIZ]; int res = pdu_pack(pdu, buffer, sizeof(buffer)); uint8_t exptected_agf_pdu_packed[] = { 0x00, 0x80, 0x00, 14, 0x23, 0x02, 0x53, 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd' }; cut_assert_equal_memory(exptected_agf_pdu_packed, sizeof(exptected_agf_pdu_packed), buffer, res, cut_message("Invalid aggregated data")); pdu_free(pdu); }
void * echo_service(void *arg) { struct llc_connection *connection = (struct llc_connection *)arg; int old_cancelstate; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate); cut_set_current_test_context(connection->link->cut_test_context); mqd_t llc_up = mq_open(connection->mq_up_name, O_RDONLY); cut_assert_false(llc_up == (mqd_t) - 1, cut_message("Can't open llc_up mqueue for reading")); mqd_t llc_down = mq_open(connection->mq_down_name, O_WRONLY); cut_assert_false(llc_down == (mqd_t) - 1, cut_message("Can't open llc_down mqueue for writing")); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); for (;;) { char buffer[1024]; int res = mq_receive(llc_up, buffer, sizeof(buffer), NULL); pthread_testcancel(); cut_assert_equal_int(7, res, cut_message("Invalid message length")); cut_assert_equal_memory(buffer, res, "\x40\xc0Hello", 7, cut_message("Invalid message data")); sem_post(sem_cutter); pthread_testcancel(); } }
void test_replace_body_large (void) { GString *actual_data; gsize i, rest_size; const gchar *packet; gsize packet_size; gsize packed_size = 0; for (i = 0; i < MILTER_CHUNK_SIZE + 500; i++) { g_string_append_c(body, 'X'); } milter_command_encoder_encode_end_of_message(command_encoder, &packet, &packet_size, NULL, 0); gcut_assert_error(feed(packet, packet_size)); milter_reply_encoder_encode_replace_body(reply_encoder, &packet, &packet_size, body->str, body->len, &packed_size); g_string_append_len(expected_packet, packet, packet_size); rest_size = body->len - packed_size; milter_reply_encoder_encode_replace_body(reply_encoder, &packet, &packet_size, body->str + packed_size, rest_size, &packed_size); g_string_append_len(expected_packet, packet, packet_size); cut_assert_equal_int(rest_size, packed_size); actual_data = gcut_string_io_channel_get_string(channel); cut_assert_equal_memory(expected_packet->str, expected_packet->len, actual_data->str, actual_data->len); }
void test_encode_negotiate (void) { MilterOption *option; const gchar *actual; gsize actual_size = 0; option = milter_option_new(2, MILTER_ACTION_ADD_HEADERS | MILTER_ACTION_CHANGE_BODY | MILTER_ACTION_ADD_ENVELOPE_RECIPIENT | MILTER_ACTION_DELETE_ENVELOPE_RECIPIENT | MILTER_ACTION_CHANGE_HEADERS | MILTER_ACTION_QUARANTINE | MILTER_ACTION_SET_SYMBOL_LIST, MILTER_STEP_NO_CONNECT | MILTER_STEP_NO_HELO | MILTER_STEP_NO_ENVELOPE_FROM | MILTER_STEP_NO_ENVELOPE_RECIPIENT | MILTER_STEP_NO_BODY | MILTER_STEP_NO_HEADERS | MILTER_STEP_NO_END_OF_HEADER); encode_negotiate_with_option(expected, option); pack(expected); milter_command_encoder_encode_negotiate(encoder, &actual, &actual_size, option); g_object_unref(option); cut_assert_equal_memory(expected->str, expected->len, actual, actual_size); }
void test_add_recipient (gconstpointer data) { GString *actual_data; const AddressTestData *test_data = data; const gchar *packet; gsize packet_size; do_add_recipient = TRUE; add_recipient = g_strdup(test_data->address); add_recipient_parameters = g_strdup(test_data->parameters); milter_command_encoder_encode_end_of_message(command_encoder, &packet, &packet_size, NULL, 0); gcut_assert_error(feed(packet, packet_size)); if (add_recipient) milter_reply_encoder_encode_add_recipient(reply_encoder, &packet, &packet_size, add_recipient, add_recipient_parameters); actual_data = gcut_string_io_channel_get_string(channel); cut_assert_equal_memory(packet, packet_size, actual_data->str, actual_data->len); }
void test_already_launched (void) { const gchar *packet; gsize packet_size; GString *output; GString *expected_packet; const gchar command_line[] = "/bin/cat"; const gchar *user_name; user_name = g_get_user_name(); milter_manager_launch_command_encoder_encode_launch(command_encoder, &packet, &packet_size, command_line, user_name); cut_trace(write_packet(packet, packet_size)); cut_trace(write_packet(packet, packet_size)); pump_all_events(); milter_manager_reply_encoder_encode_success(reply_encoder, &packet, &packet_size); expected_packet = g_string_new_len(packet, packet_size); milter_manager_reply_encoder_encode_error(reply_encoder, &packet, &packet_size, "already launched: </bin/cat>"); g_string_append_len(expected_packet, packet, packet_size); output = gcut_string_io_channel_get_string(output_channel); cut_assert_equal_memory(expected_packet->str, expected_packet->len, output->str, output->len); }
static void assert_equal_attachment (MzAttachment *expected, MzAttachment *actual) { cut_assert_not_null(actual); cut_assert_equal_string(expected->charset, actual->charset); cut_assert_equal_string(expected->filename, actual->filename); cut_assert_equal_memory(expected->data, expected->data_length, actual->data, actual->data_length); }
static void milter_test_assert_packet_helper (GIOChannel *channel, const gchar *packet, gsize packet_size) { GString *actual; actual = gcut_string_io_channel_get_string(channel); cut_assert_equal_memory(packet, packet_size, actual->str, actual->len); }
void test_mifare_ultralight_write (void) { int res; MifareUltralightPage initial; MifareUltralightPage page; MifareUltralightPage payload1 = { 0x12, 0x34, 0x56, 0x78 }; MifareUltralightPage payload2 = { 0xaa, 0x55, 0x00, 0xff }; MifareUltralightPageNumber n = 7; /* Read and save current value (should be { 0x00 0x00 0x00 0x00 }) */ res = mifare_ultralight_read (tag, n, &initial); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed")); /* Write payload1 */ res = mifare_ultralight_write (tag, n, payload1); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_write() failed")); /* Check it */ res = mifare_ultralight_read (tag, n, &page); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed")); cut_assert_equal_memory (payload1, sizeof (payload1), page, sizeof (page), cut_message ("Wrong data")); /* Write payload2 */ res = mifare_ultralight_write (tag, n, payload2); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_write() failed")); /* Check it */ res = mifare_ultralight_read (tag, n, &page); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed")); cut_assert_equal_memory (payload2, sizeof (payload2), page, sizeof (page), cut_message ("Wrong data")); /* Write initial data */ res = mifare_ultralight_write (tag, n, initial); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_write() failed")); /* While here check it (no reason to fail since the rest of the test passed) */ res = mifare_ultralight_read (tag, n, &page); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed")); cut_assert_equal_memory (initial, sizeof (initial), page, sizeof (page), cut_message ("Wrong data")); }
void test_llcp_pdu_pack(void) { uint8_t buffer[BUFSIZ]; int res = pdu_pack(sample_i_pdu, buffer, sizeof(buffer)); cut_assert_equal_int(14, res, cut_message("pdu_pack()")); cut_assert_equal_memory(sample_i_pdu_packed, sizeof(sample_i_pdu_packed), buffer, res, cut_message("Invalid packed data")); }
void test_set_and_get(void) { const char *value; uint32_t value_size; grn_test_assert(grn_conf_set(&context, "key", -1, "value", -1)); grn_test_assert(grn_conf_get(&context, "key", -1, &value, &value_size)); cut_assert_equal_memory("value", strlen("value"), value, value_size); }
void test_encode_negotiate_null (void) { const gchar *actual; gsize actual_size = 0; g_string_append_c(expected, 'O'); pack(expected); milter_command_encoder_encode_negotiate(encoder, &actual, &actual_size, NULL); cut_assert_equal_memory(expected->str, expected->len, actual, actual_size); }
void test_mifare_classic_create_trailer_block (void) { MifareClassicBlock data; MifareClassicKey key_a = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; MifareClassicKey key_b = { 0xde, 0xad, 0xbe, 0xef, 0xff, 0xff }; mifare_classic_trailer_block (&data, key_a, 0, 0, 0, 4, 0x42, key_b); cut_assert_equal_memory (data, sizeof (data), "\xff\xff\xff\xff\xff\xff\xff\x07\x80\x42\xde\xad\xbe\xef\xff\xff", sizeof (data), cut_message ("Wrong generated block")); }
void test_get_nonexistent(void) { const char *value; uint32_t value_size; grn_test_assert(grn_conf_get(&context, "noneixstent", -1, &value, &value_size)); cut_assert_equal_memory(NULL, 0, value, value_size); }
void test_tlv_decode_short (void) { uint8_t *res; uint16_t size; uint8_t type; res = tlv_decode (eshortdata, &type, &size); cut_assert_equal_int (3, type, cut_message ("Wrong type")); cut_assert_equal_int (sizeof (shortdata), size, cut_message ("Wrong value length")); cut_assert_equal_memory (shortdata, sizeof (shortdata), res, size, cut_message ("Wrong decoded value")); free (res); }
void test_tlv_encode_short (void) { uint8_t *res; size_t osize; res = tlv_encode (3, shortdata, sizeof (shortdata), &osize); cut_assert_equal_int (sizeof (eshortdata), osize, cut_message ("Wrong encoded message length.")); cut_assert_equal_int (3, res[0], cut_message ("Wrong type")); cut_assert_equal_int (sizeof (shortdata), res[1], cut_message ("Wrong value length")); cut_assert_equal_memory (eshortdata, sizeof (eshortdata), res, osize, cut_message ("Wrong encoded value")); free (res); }
void test_tlv_encode_long (void) { uint8_t *res; size_t osize; res = tlv_encode (7, longdata, sizeof (longdata), &osize); cut_assert_equal_int (sizeof (elongdata), osize, cut_message ("Wrong encoded message length.")); cut_assert_equal_int (7, res[0], cut_message ("Wrong type")); cut_assert_equal_int (0xff, res[1], cut_message ("Wrong value length")); cut_assert_equal_int (0x02, res[2], cut_message ("Wrong value length")); cut_assert_equal_int (0x94, res[3], cut_message ("Wrong value length")); cut_assert_equal_memory (elongdata, sizeof (elongdata), res, osize, cut_message ("Wrong encoded value")); free (res); }
void test_mifare_ultralight_cache_hit (void) { int res; MifareUltralightPage page1; MifareUltralightPage page2; res = mifare_ultralight_read (tag, 0, &page1); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed")); res = mifare_ultralight_read (tag, 0, &page2); cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed")); cut_assert_equal_memory (page1, sizeof (page1), page2, sizeof (page2), cut_message ("Wrong cached data")); }
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_decode_set_configuration (void) { const gchar configuration[] = "security.privilege_mode = true\n" "# comment\n"; g_string_append(buffer, "set-configuration"); g_string_append_c(buffer, '\0'); g_string_append(buffer, configuration); gcut_assert_error(decode()); cut_assert_equal_int(1, n_set_configuration_received); cut_assert_equal_memory(configuration, sizeof(configuration) - 1, actual_configuration, actual_configuration_size); }
void test_socket_address (void) { MilterGenericSocketAddress address; MilterGenericSocketAddress *actual_address; cut_assert_null(milter_client_context_get_socket_address(context)); address.address.un.sun_family = AF_UNIX; strcpy(address.address.un.sun_path, "/tmp/socket"); milter_client_context_set_socket_address(context, &address); actual_address = milter_client_context_get_socket_address(context); cut_assert_equal_memory(&address, sizeof(address), actual_address, sizeof(*actual_address)); }
void test_encode_success (void) { const gchar *actual; gsize actual_size; g_string_append(expected, "success"); g_string_append_c(expected, '\0'); pack(expected); milter_manager_reply_encoder_encode_success(encoder, &actual, &actual_size); cut_assert_equal_memory(expected->str, expected->len, actual, actual_size); }
void test_tlv_append (void) { const uint8_t a[] = { 0xde, 0xad, 0xbe, 0xef }; const uint8_t b[] = { 0x42 }; uint8_t ndef_ab_ref[] = { 0x03, 0x04, 0xde, 0xad, 0xbe, 0xef, 0x03, 0x01, 0x42, 0xfe }; uint8_t *ndef_a = tlv_encode (3, a, 4, NULL); uint8_t *ndef_b = tlv_encode (3, b, 1, NULL); ndef_a = tlv_append (ndef_a, ndef_b); cut_assert_equal_memory (ndef_ab_ref, sizeof (ndef_ab_ref), ndef_a, sizeof (ndef_ab_ref), cut_message ("Wrong appended data")); free (ndef_a); free (ndef_b); }
void test_llcp_pdu_unpack(void) { struct pdu *pdu = pdu_unpack(sample_i_pdu_packed, sizeof(sample_i_pdu_packed)); cut_assert_not_null(pdu, cut_message("pdu_unpack()")); cut_assert_equal_int(sample_i_pdu->ssap, pdu->ssap, cut_message("Wrong SSAP")); cut_assert_equal_int(sample_i_pdu->dsap, pdu->dsap, cut_message("Wrong SDAP")); cut_assert_equal_int(sample_i_pdu->ptype, pdu->ptype, cut_message("Wrong PTYPE")); cut_assert_equal_int(sample_i_pdu->ns, pdu->ns, cut_message("Wrong N(S)")); cut_assert_equal_int(sample_i_pdu->nr, pdu->nr, cut_message("Wrong N(R)")); cut_assert_equal_int(sample_i_pdu->information_size, pdu->information_size, cut_message("Wrong information size")); cut_assert_equal_memory(sample_i_pdu->information, sample_i_pdu->information_size, pdu->information, pdu->information_size, cut_message("Wrong information")); pdu_free(pdu); }
void test_stop_on_end_of_message (gconstpointer data) { const gchar *chunk = data; gsize size = 0; if (chunk) size = strlen(chunk); cut_assert_true(milter_server_context_end_of_message(context, chunk, size)); cut_assert_equal_uint(1, n_stop_on_end_of_message); cut_assert_equal_memory(chunk, size, end_of_message_chunk, end_of_message_chunk_size); cut_assert_equal_uint(1, n_stopped); cut_assert_equal_uint(0, n_accept); }
void test_encode_failure (void) { const gchar message[] = "Failure!"; const gchar *actual; gsize actual_size; g_string_append(expected, "failure"); g_string_append_c(expected, '\0'); g_string_append(expected, message); pack(expected); milter_manager_reply_encoder_encode_failure(encoder, &actual, &actual_size, message); cut_assert_equal_memory(expected->str, expected->len, actual, actual_size); }
void test_replace_body (void) { GString *actual_data; const gchar *packet; gsize packet_size; gsize packed_size = 0; g_string_append(body, "XXX"); milter_command_encoder_encode_end_of_message(command_encoder, &packet, &packet_size, NULL, 0); gcut_assert_error(feed(packet, packet_size)); milter_reply_encoder_encode_replace_body(reply_encoder, &packet, &packet_size, body->str, body->len, &packed_size); actual_data = gcut_string_io_channel_get_string(channel); cut_assert_equal_memory(packet, packet_size, actual_data->str, actual_data->len); }
void test_clear(void) { grn_id id; grn_tiny_array array; grn_tiny_array_init(&ctx, &array, sizeof(int), GRN_TINY_ARRAY_CLEAR); for (id = 1; id < (1 << 10); id++) { const int expected_value = 0; const int * const value_ptr = (const int *)grn_tiny_array_at(&array, id); cut_assert_not_null(value_ptr); cut_assert_equal_memory(&expected_value, sizeof(expected_value), value_ptr, sizeof(int)); } grn_tiny_array_fin(&array); { uint16_t element_size; for (element_size = 1; element_size < 16; element_size++) { test_basic_operations(element_size, GRN_TINY_ARRAY_CLEAR); } } }