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