static void mock_vsyslog( int priority, const char *format, va_list ap ) { check_expected( priority ); char output[ 256 ]; vsnprintf( output, sizeof( output ), format, ap ); check_expected( output ); }
int mock_accept( int sockfd, struct sockaddr *addr, socklen_t *addrlen ) { check_expected( sockfd ); check_expected( addr ); check_expected( addrlen ); check_expected( *addrlen ); return ( int ) mock(); }
int mock_execvp( /* const */ char *file, char * /* const */ argv[] ) { check_expected( file ); check_expected( argv ); check_expected( argv[ 0 ] ); check_expected( argv[ 1 ] ); return ( int ) mock(); }
jabber_conn_status_t jabber_connect_with_details(const char * const jid, const char * const passwd, const char * const altdomain, const int port, const char *const tls_policy) { check_expected(jid); check_expected(passwd); check_expected(altdomain); check_expected(port); return (jabber_conn_status_t)mock(); }
static jabber_conn_status_t _mock_jabber_connect_with_details(const char * const jid, const char * const passwd, const char * const altdomain) { check_expected(jid); check_expected(passwd); check_expected(altdomain); return (jabber_conn_status_t)mock(); }
static void callback_hello( uint16_t tag, void *data, size_t len ) { check_expected( tag ); check_expected( data ); check_expected( len ); stop_event_handler(); stop_messenger(); }
bool mock_switch_send_openflow_message( buffer *buffer ) { struct ofp_header *header = buffer->data; check_expected( buffer->length ); if ( header->type == OFPT_GET_CONFIG_REPLY ) { check_expected( ( ( struct ofp_switch_config * ) buffer->data )->flags ); } return true; }
static gboolean _mock_bookmark_add(const char *jid, const char *nick, const char *password, const char *autojoin_str) { check_expected(jid); check_expected(nick); check_expected(password); check_expected(autojoin_str); return (gboolean)mock(); }
void ui_current_print_formatted_line(const char show_char, int attrs, const char * const msg, ...) { check_expected(show_char); check_expected(attrs); va_list args; va_start(args, msg); vsnprintf(output, sizeof(output), msg, args); check_expected(output); va_end(args); }
ssize_t mock_read( int fd, void *buf, size_t count ) { check_expected( fd ); check_expected( buf ); check_expected( count ); if ( read_length > 0 ) { memcpy( buf, read_buffer, read_length ); } return ( int ) mock(); }
pid_t mock_wait3( int *status, int options, struct rusage *rusage ) { check_expected( status ); check_expected( options ); check_expected( rusage ); *status = mock_wait3_status; return ( pid_t ) mock(); }
int mock_setsockopt( int sockfd, int level, int optname, /* const */ void *optval, socklen_t optlen ) { check_expected( sockfd ); check_expected( level ); check_expected( optname ); check_expected( optval ); check_expected( optlen ); return ( int ) mock(); }
void mock_insert_match_entry( struct ofp_match *ofp_match, uint16_t priority, /* const */ char *service_name, /* const */ char *entry_name ) { uint32_t priority32 = priority; check_expected( ofp_match ); check_expected( priority32 ); check_expected( service_name ); check_expected( entry_name ); ( void ) mock(); }
bool mock_send_message( /* const */ char *service_name, const uint16_t tag, /* const */ void *data, size_t len ) { uint32_t tag32 = tag; check_expected( service_name ); check_expected( tag32 ); check_expected( data ); check_expected( len ); return ( bool ) mock(); }
static void test_mock_ssh_logging_callback(int priority, const char *function, const char *buffer, void *userdata) { struct test_mock_state *t = (struct test_mock_state *)userdata; check_expected(priority); check_expected(function); check_expected(buffer); t->executed++; }
static size_t __wrap_coco_suite_encode_problem_index(coco_suite_t *suite, const size_t function_idx, const size_t dimension_idx, const size_t instance_idx) { printf("INFO: function __wrap_coco_suite_encode_problem_index.\n"); check_expected(function_idx); check_expected(dimension_idx); check_expected(instance_idx); (void)suite; /* unused */ return (size_t) mock(); }
void mock_set_match_from_packet( struct ofp_match *match, const uint16_t in_port, const uint32_t wildcards, /* const */ buffer *packet ) { uint32_t in_port32 = in_port; check_expected( match ); check_expected( in_port32 ); check_expected( wildcards ); check_expected( packet ); memset( match, 0, sizeof( struct ofp_match ) ); match->in_port = in_port; match->wildcards = wildcards; ( void ) mock(); }
static void mock_warn_check( char *format, va_list args ) { char message[ 1000 ]; vsnprintf( message, 1000, format, args ); check_expected( message ); }
void cons_show_error(const char * const cmd, ...) { va_list args; va_start(args, cmd); vsnprintf(output, sizeof(output), cmd, args); check_expected(output); va_end(args); }
void cons_show(const char * const msg, ...) { va_list args; va_start(args, msg); vsnprintf(output, sizeof(output), msg, args); check_expected(output); va_end(args); }
int write_output(const char *buf, size_t buf_len) { check_expected(buf_len); return mock(); (void)buf; }
void ui_current_print_line(const char * const msg, ...) { va_list args; va_start(args, msg); vsnprintf(output, sizeof(output), msg, args); check_expected(output); va_end(args); }
static long __wrap_suite_bbob2009_get_next_problem_index( long problem_index, const char *selection_descriptor) { printf("INFO: function __wrap_suite_bbob2009_get_next_problem_index.\n"); check_expected(problem_index); return (long) mock(); }
static bool mock_add_message_replied_callback( const char *service_name, void ( *callback )( uint16_t tag, void *data, size_t len, void *user_data ) ) { check_expected( service_name ); assert_true( callback != NULL ); handle_reply = callback; return ( bool ) mock(); }
static int mock_vprintf( const char *format, va_list ap ) { char output[ 256 ]; vsnprintf( output, sizeof( output ), format, ap ); check_expected( output ); return 0; }
static void mock_critical( const char *format, ... ) { char output[ 256 ]; va_list args; va_start( args, format ); vsprintf( output, format, args ); va_end( args ); check_expected( output ); }
/* A mock printf function that checks the value of strings printed to the * standard output stream. */ int example_test_printf(const char *format, ...) { int return_value; va_list args; va_start(args, format); return_value = vsnprintf(temporary_buffer, sizeof(temporary_buffer), format, args); check_expected(temporary_buffer); va_end(args); return return_value; }
void mock_info( const char *format, ... ) { va_list args; va_start( args, format ); char message[ 1000 ]; vsprintf( message, format, args ); va_end( args ); check_expected( message ); }
static void mock_die( const char *format, ... ) { char output[ 256 ]; va_list args; va_start( args, format ); vsprintf( output, format, args ); va_end( args ); check_expected( output ); mock_assert( false, "mock_die", __FILE__, __LINE__ ); } // Hoaxes gcov.
void mock_die( char *format, ... ) { va_list args; va_start( args, format ); char message[ 1000 ]; vsprintf( message, format, args ); va_end( args ); check_expected( message ); mock_assert( false, "UNREACHABLE", __FILE__, __LINE__ ); } // This hoaxes gcov.