// Ensure perform_operation() succeeds given valid input parameters.
void test_perform_operation(void **state) {
const OperatorFunction operator_functions[] = {
{"+", binary_operator},
{"*", binary_operator},
};
char *args[] = {
"1", "+", "3", "*", "10",
};
int number_of_intermediate_values;
int *intermediate_values;
int error_occurred;
// Setup return values of mock operator functions.
// Addition.
expect_value(binary_operator, a, 1);
expect_value(binary_operator, b, 3);
will_return(binary_operator, 4);
// Multiplication.
expect_value(binary_operator, a, 4);
expect_value(binary_operator, b, 10);
will_return(binary_operator, 40);
assert_int_equal(perform_operation(
array_length(args), args, array_length(operator_functions),
operator_functions, &number_of_intermediate_values,
&intermediate_values, &error_occurred), 40);
assert_int_equal(error_occurred, 0);
assert_true(intermediate_values);
assert_int_equal(intermediate_values[0], 4);
assert_int_equal(intermediate_values[1], 40);
test_free(intermediate_values);
}
static void
test_send_then_message_requested_and_replied_callback_is_called() {
init_messenger( "/tmp" );
const char service_name[] = "Say HELLO";
expect_value( callback_req_hello, tag, 43556 );
expect_string( callback_req_hello, data, "HELLO" );
expect_value( callback_req_hello, len, 6 );
add_message_requested_callback( service_name, callback_req_hello );
expect_value( callback_rep_hello_end, tag, 65534 );
expect_string( callback_rep_hello_end, data, "OLLEH" );
expect_value( callback_rep_hello_end, len, 6 );
expect_value( callback_rep_hello_end, user_data, NULL );
add_message_replied_callback( service_name, callback_rep_hello_end );
send_request_message( service_name, service_name, 43556, "HELLO", strlen( "HELLO" ) + 1, NULL );
start_messenger();
start_event_handler();
delete_message_replied_callback( service_name, callback_rep_hello_end );
delete_message_requested_callback( service_name, callback_req_hello );
delete_send_queue( lookup_hash_entry( send_queues, service_name ) );
finalize_messenger();
}
static void
create_port_desc( void **state ) {
UNUSED( state );
int ret = init_port_manager( SELECT_TIMEOUT_USEC, MAX_SEND_QUEUE, MAX_RECV_QUEUE );
if ( ret != OFDPE_SUCCESS ) {
return;
}
expect_string( mock_create_ether_device, name, DEV_NAME );
expect_value( mock_create_ether_device, max_send_queue, MAX_SEND_QUEUE );
expect_value( mock_create_ether_device, max_recv_queue, MAX_RECV_QUEUE );
switch_port *port = ( switch_port * ) xmalloc( sizeof( switch_port ) );
port->device = ( ether_device * ) xmalloc( sizeof( ether_device ) );
memcpy( port->device->name, DEV_NAME, sizeof( port->device->name ) );
memcpy( port->device->hw_addr, HW_ADDR, sizeof( port->device->hw_addr ) );
will_return( mock_create_ether_device, port->device );
expect_value( mock_send_for_notify_port_config, port_no, PORT_NO );
expect_value( mock_send_for_notify_port_config, reason, OFPPR_ADD );
char *device_name = xstrdup( DEV_NAME );
ret = add_port( PORT_NO, device_name );
xfree( device_name );
}
void
ui_current_print_formatted_line_expect(char show_char, int attrs, char *message)
{
expect_value(_mock_ui_current_print_formatted_line, show_char, show_char);
expect_value(_mock_ui_current_print_formatted_line, attrs, attrs);
expect_string(_mock_ui_current_print_formatted_line, output, message);
}
static void
test_handle_packet_in_lookup_failed() {
setup();
uint64_t datapath_id = 0x101;
uint32_t transaction_id = 1234;
uint32_t buffer_id = 0;
uint16_t total_len = 0;
uint32_t in_port32 = 1;
uint8_t reason = 0;
buffer *data;
void *user_data = NULL;
data = alloc_buffer();
expect_not_value( mock_set_match_from_packet, match, NULL );
expect_value( mock_set_match_from_packet, in_port32, in_port32 );
expect_value( mock_set_match_from_packet, wildcards, 0 );
expect_value( mock_set_match_from_packet, packet, data );
will_return_void( mock_set_match_from_packet );
expect_not_value( mock_lookup_match_entry, match, NULL );
will_return( mock_lookup_match_entry, NULL );
handle_packet_in( datapath_id, transaction_id, buffer_id, total_len,
( uint16_t ) in_port32, reason, data, user_data );
free_buffer( data );
teardown();
}
void
presence_update_expect(resource_presence_t presence, char *msg, int idle)
{
expect_value(_mock_presence_update, status, presence);
expect_string(_mock_presence_update, msg, msg);
expect_value(_mock_presence_update, idle, idle);
}
/*
* Test that the ExecWorkFile struct is allocated in TopMemoryContext
*/
void
test__ExecWorkFile_Create__InTopMemContext(void **state)
{
char *test_filename = "foo";
will_return(WorkfileQueryspace_AddWorkfile, true);
expect_value(BufFileCreateFile, fileName, test_filename);
expect_value(BufFileCreateFile, delOnClose, true);
expect_value(BufFileCreateFile, interXact, false);
will_return(BufFileCreateFile, NULL);
expect_value(BufFileSetWorkfile, buffile, NULL);
will_be_called(BufFileSetWorkfile);
/*
* Create a new memory context, so that we can distinguish it from
* TopMemoryContext.
*/
CurrentMemoryContext =
AllocSetContextCreate(TopMemoryContext,
"mock test context",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
/*
* ExecWorkFile_Create will call our mocked palloc0 function execWorkfile__palloc0_mock
* and our mocked pstrdup function execWorkfile_pstrdup_mock.
* These functions will assert that the allocation of the result happens
* in the TopMemoryContext.
*/
ExecWorkFile *ewf = ExecWorkFile_Create(test_filename, BUFFILE, true /* delOnClose */, 0 /* compressType */);
}
/*
* Test failure to allocate bitmap buffer for child
*/
void test_cbt_util_coalesce_child_bitmap_malloc_failure(void **state)
{
int result;
uint64_t disk_size, file_size;
char* args[] = { "cbt-util", "coalesce", "-p", "test_parent.log", "-c" , "test_child.log"};
void *log_meta;
disk_size = 2199023255552; //2TB
file_size = bitmap_size(disk_size) + sizeof(struct cbt_log_metadata);
log_meta = malloc(file_size);
((struct cbt_log_metadata*)log_meta)->size = disk_size;
FILE *parent_log = fmemopen((void*)log_meta, file_size, "r");
FILE *child_log = fmemopen((void*)log_meta, file_size, "r+");
will_return(__wrap_fopen, parent_log);
expect_value(__wrap_fclose, fp, parent_log);
will_return(__wrap_fopen, child_log);
expect_value(__wrap_fclose, fp, child_log);
malloc_succeeds(true);
malloc_succeeds(true);
malloc_succeeds(true);
malloc_succeeds(false);
result = cbt_util_coalesce(6, args);
assert_int_equal(result, -ENOMEM);
disable_malloc_mock();
free(log_meta);
}
/*
* Test failure to read bitmap from child log file
*/
void test_cbt_util_coalesce_child_no_bitmap_data_failure(void **state)
{
int result;
char* args[] = { "cbt-util", "coalesce", "-p", "test_parent.log", "-c" , "test_child.log"};
void *parent_meta;
void *child_meta;
uint64_t disk_size, file_size;
disk_size = 2199023255552; //2TB
file_size = bitmap_size(disk_size) + sizeof(struct cbt_log_metadata);
parent_meta = malloc(file_size);
child_meta = malloc(sizeof(struct cbt_log_metadata));
//Intialise size in metadata file
((struct cbt_log_metadata*)parent_meta)->size = disk_size;
((struct cbt_log_metadata*)child_meta)->size = disk_size;
FILE *parent_log = fmemopen((void*)parent_meta, file_size, "r");
FILE *child_log = fmemopen((void*)child_meta,
sizeof(struct cbt_log_metadata), "r+");
will_return(__wrap_fopen, parent_log);
expect_value(__wrap_fclose, fp, parent_log);
will_return(__wrap_fopen, child_log);
expect_value(__wrap_fclose, fp, child_log);
result = cbt_util_coalesce(6, args);
assert_int_equal(result, -EIO);
free(parent_meta);
free(child_meta);
}
/*
* Test failure when parent bitmap is larger than child bitmap
*/
void test_cbt_util_coalesce_larger_parent_bitmap_failure(void **state)
{
int result;
char* args[] = { "cbt-util", "coalesce", "-p", "test_parent.log", "-c" , "test_child.log"};
void *parent_meta;
void *child_meta;
parent_meta = malloc(sizeof(struct cbt_log_metadata));
child_meta = malloc(sizeof(struct cbt_log_metadata));
((struct cbt_log_metadata *)parent_meta)->size = 1310720;
((struct cbt_log_metadata *)child_meta)->size = 655360;
FILE *parent_log = fmemopen((void*)parent_meta,
sizeof(struct cbt_log_metadata), "r");
FILE *child_log = fmemopen((void*)child_meta,
sizeof(struct cbt_log_metadata), "r");
will_return(__wrap_fopen, parent_log);
expect_value(__wrap_fclose, fp, parent_log);
will_return(__wrap_fopen, child_log);
expect_value(__wrap_fclose, fp, child_log);
result = cbt_util_coalesce(6, args);
assert_int_equal(result, -EINVAL);
free(parent_meta);
free(child_meta);
}
/*
* Test failure to malloc cbt_log_metadata structure for child
*/
void test_cbt_util_coalesce_child_log_malloc_failure(void **state)
{
int result;
char* args[] = { "cbt-util", "coalesce", "-p", "test_parent.log", "-c" , "test_child.log"};
void *log_meta;
log_meta = malloc(sizeof(struct cbt_log_metadata));
FILE *parent_log = fmemopen((void*)log_meta,
sizeof(struct cbt_log_metadata), "r");
FILE *child_log = fmemopen((void*)log_meta,
sizeof(struct cbt_log_metadata), "r");
will_return(__wrap_fopen, parent_log);
expect_value(__wrap_fclose, fp, parent_log);
will_return(__wrap_fopen, child_log);
expect_value(__wrap_fclose, fp, child_log);
malloc_succeeds(true);
malloc_succeeds(false);
result = cbt_util_coalesce(6, args);
assert_int_equal(result, -ENOMEM);
disable_malloc_mock();
free(log_meta);
}
void cmd_connect_with_port_when_provided(void **state)
{
CommandHelp *help = malloc(sizeof(CommandHelp));
gchar *args[] = { "*****@*****.**", "port", "5432", NULL };
will_return(jabber_get_connection_status, JABBER_DISCONNECTED);
expect_string(accounts_get_account, name, "*****@*****.**");
will_return(accounts_get_account, NULL);
will_return(ui_ask_password, strdup("password"));
expect_cons_show("Connecting as [email protected]");
expect_string(jabber_connect_with_details, jid, "*****@*****.**");
expect_string(jabber_connect_with_details, passwd, "password");
expect_value(jabber_connect_with_details, altdomain, NULL);
expect_value(jabber_connect_with_details, port, 5432);
will_return(jabber_connect_with_details, JABBER_CONNECTING);
gboolean result = cmd_connect(NULL, args, *help);
assert_true(result);
free(help);
}
void
test_init_log_opens_syslog() {
const char *ident = "tetris";
expect_string( mock_openlog, ident, ident );
expect_value( mock_openlog, option, LOG_NDELAY );
expect_value( mock_openlog, facility, LOG_USER );
init_log( ident, get_trema_tmp(), LOGGING_TYPE_SYSLOG );
assert_true( syslog_initialized );
}
static void
setup_logger_syslog() {
setup();
const char *ident = "log_test.c";
expect_string( mock_openlog, ident, ident );
expect_value( mock_openlog, option, LOG_NDELAY );
expect_value( mock_openlog, facility, LOG_USER );
init_log( ident, get_trema_tmp(), LOGGING_TYPE_SYSLOG );
}
static void
expect_lwlock(LWLockMode lockmode)
{
expect_value(LWLockAcquire, l, SyncRepLock);
expect_value(LWLockAcquire, mode, lockmode);
will_return(LWLockAcquire, true);
expect_value(LWLockRelease, l, SyncRepLock);
will_be_called(LWLockRelease);
}
static void
test_handle_packet_in_send_failed() {
setup();
uint64_t datapath_id = 0x101;
uint32_t transaction_id = 1234;
uint32_t buffer_id = 0;
uint32_t total_len32 = 0;
uint32_t in_port32 = 1;
uint32_t reason32 = 0;
buffer *data;
void *user_data = NULL;
match_entry match_entry;
buffer *buf;
data = alloc_buffer();
expect_not_value( mock_set_match_from_packet, match, NULL );
expect_value( mock_set_match_from_packet, in_port32, in_port32 );
expect_value( mock_set_match_from_packet, wildcards, 0 );
expect_value( mock_set_match_from_packet, packet, data );
will_return_void( mock_set_match_from_packet );
memset( &match_entry, 0, sizeof( match_entry ) );
match_entry.service_name = ( char * ) ( uintptr_t ) ( "service_name" );
match_entry.entry_name = ( char * ) ( uintptr_t ) ( "entry_name" );
expect_not_value( mock_lookup_match_entry, match, NULL );
will_return( mock_lookup_match_entry, &match_entry );
buf = alloc_buffer();
expect_value( mock_create_packet_in, transaction_id, transaction_id );
expect_value( mock_create_packet_in, buffer_id, buffer_id );
expect_value( mock_create_packet_in, total_len32, total_len32 );
expect_value( mock_create_packet_in, in_port32, in_port32 );
expect_value( mock_create_packet_in, reason32, reason32 );
expect_value( mock_create_packet_in, data, data );
will_return( mock_create_packet_in, buf );
expect_string( mock_send_message, service_name, match_entry.service_name );
expect_value( mock_send_message, tag32, MESSENGER_OPENFLOW_MESSAGE );
expect_not_value( mock_send_message, data, NULL );
expect_not_value( mock_send_message, len, 0 );
will_return( mock_send_message, false );
expect_string( mock_error, buffer, "Failed to send a message to service_name ( entry_name = entry_name, match = wildcards = 0, in_port = 1, dl_src = 00:00:00:00:00:00, dl_dst = 00:00:00:00:00:00, dl_vlan = 0, dl_vlan_pcp = 0, dl_type = 0, nw_tos = 0, nw_proto = 0, nw_src = 0.0.0.0, nw_dst = 0.0.0.0, tp_src = 0, tp_dst = 0 )." );
will_return_void( mock_error );
handle_packet_in( datapath_id, transaction_id, buffer_id, ( uint16_t ) total_len32,
( uint16_t ) in_port32, ( uint8_t ) reason32, data, user_data );
free_buffer( data );
teardown();
}
void
test_build_http_headers_empty_user_error(void **state) {
/* setup mock data and expectations */
PxfInputData *input = (PxfInputData *) palloc0(sizeof(PxfInputData));
CHURL_HEADERS headers = (CHURL_HEADERS) palloc0(sizeof(CHURL_HEADERS));
GPHDUri *gphd_uri = (GPHDUri *) palloc0(sizeof(GPHDUri));
Relation rel = (Relation) palloc0(sizeof(RelationData));
ExtTableEntry ext_tbl;
struct tupleDesc tuple;
input->headers = headers;
input->gphduri = gphd_uri;
input->rel = NULL;
gphd_uri->uri = "testuri";
expect_any(external_set_env_vars, extvar);
expect_string(external_set_env_vars, uri, gphd_uri->uri);
expect_value(external_set_env_vars, csv, false);
expect_value(external_set_env_vars, escape, NULL);
expect_value(external_set_env_vars, quote, NULL);
expect_value(external_set_env_vars, header, false);
expect_value(external_set_env_vars, scancounter, 0);
struct extvar_t mock_extvar;
mock_extvar.GP_USER = "";
snprintf(mock_extvar.GP_SEGMENT_ID, sizeof(mock_extvar.GP_SEGMENT_ID), "SegId");
snprintf(mock_extvar.GP_SEGMENT_COUNT, sizeof(mock_extvar.GP_SEGMENT_COUNT), "10");
snprintf(mock_extvar.GP_XID, sizeof(mock_extvar.GP_XID), "20");
will_assign_memory(external_set_env_vars, extvar, &mock_extvar, sizeof(extvar_t));
will_be_called(external_set_env_vars);
MemoryContext old_context = CurrentMemoryContext;
PG_TRY();
{
build_http_headers(input);
assert_false("Expected Exception");
}
PG_CATCH();
{
MemoryContextSwitchTo(old_context);
ErrorData *edata = CopyErrorData();
assert_true(edata->elevel == ERROR);
char *expected_message = pstrdup("User identity is unknown");
assert_string_equal(edata->message, expected_message);
pfree(expected_message);
}
PG_END_TRY();
}
void expect_external_vars()
{
expect_any(external_set_env_vars, extvar);
expect_string(external_set_env_vars, uri, gphd_uri->uri);
expect_value(external_set_env_vars, csv, false);
expect_value(external_set_env_vars, escape, NULL);
expect_value(external_set_env_vars, quote, NULL);
expect_value(external_set_env_vars, header, false);
expect_value(external_set_env_vars, scancounter, 0);
will_assign_memory(external_set_env_vars, extvar, mock_extvar, sizeof(extvar_t));
will_be_called(external_set_env_vars);
}
void cmd_account_add_adds_account(void **state)
{
gchar *args[] = { "add", "new_account", NULL };
expect_string(accounts_add, jid, "new_account");
expect_value(accounts_add, altdomain, NULL);
expect_value(accounts_add, port, 0);
expect_cons_show("Account created.");
expect_cons_show("");
gboolean result = cmd_account_add(NULL, CMD_ACCOUNT, args);
assert_true(result);
}
void
jabber_connect_with_details_expect_and_return(char *jid,
char *password, char *altdomain, int port, jabber_conn_status_t result)
{
expect_string(_mock_jabber_connect_with_details, jid, jid);
expect_string(_mock_jabber_connect_with_details, passwd, password);
if (altdomain == NULL) {
expect_value(_mock_jabber_connect_with_details, altdomain, NULL);
} else {
expect_string(_mock_jabber_connect_with_details, altdomain, altdomain);
}
expect_value(_mock_jabber_connect_with_details, port, port);
will_return(_mock_jabber_connect_with_details, result);
}
static void
test_daemonize_succeed() {
will_return( mock_chdir, 0 );
will_return( mock_fork, 1234 );
will_return( mock_setsid, 4321 );
expect_value( mock_exit, status, EXIT_SUCCESS );
expect_value( mock_umask, mode, 0 );
expect_value( mock_close, fd, STDIN_FILENO );
expect_value( mock_close, fd, STDOUT_FILENO );
expect_value( mock_close, fd, STDERR_FILENO );
daemonize( "/" );
}
static void
test_write_pid_fail_if_open_fail() {
will_return( mock_open, -1 );
// Test if correctly opened.
char path[] = "/home/yasuhito/trema/tmp/chess.pid";
expect_string( mock_open, pathname, path );
expect_value( mock_open, flags, ( O_RDWR | O_CREAT ) );
expect_value( mock_open, mode, 0600 );
expect_string( mock_die, message, "Could not create a PID file: /home/yasuhito/trema/tmp/chess.pid" );
expect_assert_failure( write_pid( "/home/yasuhito/trema/tmp", "chess" ) );
}
void cmd_join_uses_account_mucservice_when_no_service_specified(void **state)
{
char *account_name = "an_account";
char *room = "room";
char *nick = "bob";
char *account_service = "conference.server.org";
char *expected_room = "*****@*****.**";
gchar *args[] = { room, "nick", nick, NULL };
ProfAccount *account = account_new(account_name, "*****@*****.**", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, account_service, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
muc_init();
will_return(connection_get_status, JABBER_CONNECTED);
will_return(session_get_account_name, account_name);
expect_string(accounts_get_account, name, account_name);
will_return(accounts_get_account, account);
expect_string(presence_join_room, room, expected_room);
expect_string(presence_join_room, nick, nick);
expect_value(presence_join_room, passwd, NULL);
gboolean result = cmd_join(NULL, CMD_JOIN, args);
assert_true(result);
}
static void
test_secure_channel_accept_accept_failed() {
int listen_fd = 0;
listener_info.listen_fd = listen_fd;
expect_value( mock_accept, sockfd, listen_fd );
expect_not_value( mock_accept, addr, NULL );
expect_not_value( mock_accept, addrlen, NULL );
expect_value( mock_accept, *addrlen, sizeof( struct sockaddr_in ) );
will_return( mock_accept, -1 );
secure_channel_accept( &listener_info );
teardown();
}
static void
test_switch_manager_main_help_and_exit() {
setup();
char *argv[] = {
( char * )( uintptr_t )"switch_manager",
( char * )( uintptr_t )"-x",
NULL,
};
int argc = ARRAY_SIZE( argv ) - 1;
int ret;
will_return( mock_printf2, 1 );
will_return( mock_get_current_dir_name, strdup( "/tmp" ) );
will_return_void( mock_init_trema );
will_return( mock_get_trema_home, strdup( "/tmp" ) );
expect_value( mock_exit, status, EXIT_SUCCESS );
will_return_void( mock_exit );
optind = 1;
ret = switch_manager_main( argc, argv );
assert_true( ret == EXIT_FAILURE );
teardown();
}
static void
test_wait_child_wait3_zero_return() {
setup();
expect_not_value( mock_wait3, status, NULL );
expect_value( mock_wait3, options, WNOHANG );
expect_value( mock_wait3, rusage, NULL );
mock_wait3_status = 0;
will_return( mock_wait3, 0 );
wait_child();
teardown();
}
void
ui_switch_win_expect_and_return(int given_i, gboolean result)
{
ui_switch_win = _mock_ui_switch_win;
expect_value(_mock_ui_switch_win, i, given_i);
will_return(_mock_ui_switch_win, result);
}
void
ui_room_join_expect(char *room, gboolean focus)
{
ui_room_join = _mock_ui_room_join;
expect_string(_mock_ui_room_join, room, room);
expect_value(_mock_ui_room_join, focus, focus);
}
static void torture_log_callback(void **state)
{
struct test_mock_state t = {
.executed = 0,
};
(void)state; /* unused */
ssh_set_log_callback(test_mock_ssh_logging_callback);
ssh_set_log_userdata(&t);
ssh_set_log_level(1);
expect_value(test_mock_ssh_logging_callback, priority, 1);
expect_string(test_mock_ssh_logging_callback, function, "torture_log_callback");
expect_string(test_mock_ssh_logging_callback, buffer, "torture_log_callback: test");
SSH_LOG(SSH_LOG_WARN, "test");
assert_int_equal(t.executed, 1);
}
int torture_run_tests(void) {
int rc;
UnitTest tests[] = {
unit_test_setup_teardown(torture_callbacks_size, setup, teardown),
unit_test_setup_teardown(torture_callbacks_exists, setup, teardown),
unit_test(torture_log_callback),
};
ssh_init();
torture_filter_tests(tests);
rc=run_tests(tests);
ssh_finalize();
return rc;
}
/*
* Test that the spill_file->file_info->wfile field is allocated
* and initialized during normal execution (no exception thrown).
*/
void
test__getSpillFile__Initialize_wfile_success(void **state)
{
int alloc_size = 0;
int file_no = 0;
int branching_factor = 32;
ExecWorkFile *ewfile = (ExecWorkFile *) palloc0(sizeof(ExecWorkFile));
workfile_set *work_set = (workfile_set *) palloc0(sizeof(workfile_set));
SpillSet *spill_set = (SpillSet *) palloc0(sizeof(SpillSet) + (branching_factor-1) * sizeof (SpillFile));
SpillFile *spill_file = &spill_set->spill_files[file_no];
spill_file->file_info = NULL;
expect_value(workfile_mgr_create_file, work_set, work_set);
will_return(workfile_mgr_create_file, ewfile);
getSpillFile(work_set, spill_set, file_no, &alloc_size);
assert_true(spill_file->file_info != NULL);
assert_int_equal(spill_file->file_info->total_bytes, 0);
assert_int_equal(spill_file->file_info->ntuples, 0);
assert_int_equal(alloc_size, BATCHFILE_METADATA);
/*
* During normal execution, wfile should be initialized with
* the result of workfile_mgr_create_wfile, a valid ExecWorkFile pointer
*/
assert_true(spill_file->file_info->wfile == ewfile);
}
