test_amxb_ba_invoke.c File Reference

#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_variant.h>
#include <amxc/amxc_htable.h>
#include <amxc/amxc_lqueue.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.h>
#include <amxd/amxd_dm.h>
#include <amxb/amxb_be.h>
#include <amxb/amxb.h>
#include "test_amxb_ba_invoke.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
int	__wrap_dlclose (void *handle)
static void *	dummy_connect (const char *host, const char *port, const char *path, UNUSED amxp_signal_mngr_t *sigmngr)
static int	dummy_disconnect (void *ctx)
static int	dummy_get_fd (void *ctx)
static void	dummy_free (void *ctx)
static int	dummy_read (void *const ctx)
static int	dummy_new_invoke (amxb_invoke_t *invoke_ctx)
static void	dummy_free_invoke (amxb_invoke_t *invoke_ctx)
static int	dummy_invoke (void *const ctx, amxb_invoke_t *invoke_ctx, UNUSED amxc_var_t *args, amxb_request_t *request, int timeout)
static int	dummy_async_invoke (void *const ctx, amxb_invoke_t *invoke_ctx, UNUSED amxc_var_t *args, amxb_request_t *request)
static int	dummy_wait_request (void *const ctx, amxb_request_t *request, UNUSED int timeout)
static int	dummy_close_request (void *const ctx, amxb_request_t *request)
int	__wrap_dlclose (UNUSED void *handle)
void	test_amxb_new_free_invoke (UNUSED void **state)
void	test_amxb_invoke (UNUSED void **state)
void	test_amxb_async_invoke_and_close (UNUSED void **state)
void	test_amxb_api_after_backend_removal (UNUSED void **state)
void	test_amxb_wait_for_request (UNUSED void **state)
void	test_amxb_async_call (UNUSED void **state)

Variables
static char *	dummy_ctx = "xbus"
static char *	dummy_bus_data = "xbus dummy data"
static char	verify_host [64]
static char	verify_port [64]
static char	verify_path [64]
static int	return_val
static amxb_be_funcs_t	dummy_be1
static amxb_be_funcs_t	dummy_be3
static amxb_be_funcs_t	dummy_be4

Function Documentation

__wrap_dlclose() [1/2]

int __wrap_dlclose

(

UNUSED void *

handle

)

Definition at line 196 of file test_amxb_ba_invoke.c.

                                        {
    return 0;
}

__wrap_dlclose() [2/2]

int __wrap_dlclose

(

void *

handle

)

dummy_async_invoke()

static int dummy_async_invoke ( void *const  ctx, amxb_invoke_t *  invoke_ctx, UNUSED amxc_var_t *  args, amxb_request_t *  request  )

static

Definition at line 140 of file test_amxb_ba_invoke.c.

                                                       {
    assert_ptr_equal(ctx, dummy_ctx);
    assert_string_equal(invoke_ctx->object, "object");
    assert_string_equal(invoke_ctx->method, "method");
    request->bus_data = dummy_bus_data;
    return return_val;
}

dummy_close_request()

static int dummy_close_request ( void *const  ctx, amxb_request_t *  request  )

static

Definition at line 160 of file test_amxb_ba_invoke.c.

                                                        {
    assert_ptr_equal(ctx, dummy_ctx);
    assert_ptr_equal(request->bus_data, dummy_bus_data);
    return return_val;
}

dummy_connect()

static void* dummy_connect ( const char *  host, const char *  port, const char *  path, UNUSED amxp_signal_mngr_t *  sigmngr  )

static

Definition at line 87 of file test_amxb_ba_invoke.c.

                                                               {
    strcpy(verify_host, host);
    strcpy(verify_port, port);
    strcpy(verify_path, path);
 
    return dummy_ctx;
}

dummy_disconnect()

static int dummy_disconnect ( void *  ctx )

static

Definition at line 98 of file test_amxb_ba_invoke.c.

                                       {
    assert_ptr_equal(ctx, dummy_ctx);
    return return_val;
}

dummy_free()

static void dummy_free ( void *  ctx )

static

Definition at line 108 of file test_amxb_ba_invoke.c.

                                  {
    assert_ptr_equal(ctx, dummy_ctx);
}

dummy_free_invoke()

static void dummy_free_invoke ( amxb_invoke_t *  invoke_ctx )

static

Definition at line 122 of file test_amxb_ba_invoke.c.

                                                         {
    assert_ptr_not_equal(invoke_ctx, NULL);
    return;
}

dummy_get_fd()

static int dummy_get_fd ( void *  ctx )

static

Definition at line 103 of file test_amxb_ba_invoke.c.

                                   {
    assert_ptr_equal(ctx, dummy_ctx);
    return return_val;
}

dummy_invoke()

static int dummy_invoke ( void *const  ctx, amxb_invoke_t *  invoke_ctx, UNUSED amxc_var_t *  args, amxb_request_t *  request, int  timeout  )

static

Definition at line 127 of file test_amxb_ba_invoke.c.

                                     {
    assert_ptr_equal(ctx, dummy_ctx);
    assert_string_equal(invoke_ctx->object, "object");
    assert_string_equal(invoke_ctx->method, "method");
    assert_ptr_not_equal(request, NULL);
    assert_int_equal(timeout, 10);
    return return_val;
}

dummy_new_invoke()

static int dummy_new_invoke ( amxb_invoke_t *  invoke_ctx )

static

Definition at line 117 of file test_amxb_ba_invoke.c.

                                                       {
    assert_ptr_not_equal(invoke_ctx, NULL);
    return return_val;
}

dummy_read()

static int dummy_read ( void *const  ctx )

static

Definition at line 112 of file test_amxb_ba_invoke.c.

                                       {
    assert_ptr_equal(ctx, dummy_ctx);
    return return_val;
}

dummy_wait_request()

static int dummy_wait_request ( void *const  ctx, amxb_request_t *  request, UNUSED int  timeout  )

static

Definition at line 151 of file test_amxb_ba_invoke.c.

                                                  {
    assert_ptr_equal(ctx, dummy_ctx);
    assert_ptr_equal(request->bus_data, dummy_bus_data);
 
    return return_val;
}

test_amxb_api_after_backend_removal()

void test_amxb_api_after_backend_removal

(

UNUSED void **

state

)

Definition at line 382 of file test_amxb_ba_invoke.c.

                                                              {
    amxb_bus_ctx_t* ctx = NULL;
    amxb_request_t* request = NULL;
    amxb_invoke_t* invoke_ctx = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
 
    return_val = 0;
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), return_val);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    ctx = NULL;
 
    assert_int_not_equal(amxb_disconnect(ctx), 0);
    assert_int_not_equal(amxb_read(ctx), 0);
    assert_int_equal(amxb_get_fd(ctx), -1);
    assert_int_equal(amxb_close_request(&request), 0);
    assert_ptr_equal(request, NULL);
    assert_int_not_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), 0);
    assert_ptr_equal(request, NULL);
    assert_int_not_equal(amxb_invoke(invoke_ctx, NULL, NULL, NULL, NULL, 10), 0);
 
    amxb_free_invoke(&invoke_ctx);
    amxb_free(&ctx);
}

test_amxb_async_call()

void test_amxb_async_call

(

UNUSED void **

state

)

Definition at line 450 of file test_amxb_ba_invoke.c.

                                               {
    amxb_bus_ctx_t* ctx = NULL;
    amxb_request_t* request = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be4), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://atest:8080/var/run/xbus.sock"), 0);
    return_val = 0;
    request = amxb_async_call(ctx, "object", "method", NULL, NULL, NULL);
    assert_non_null(request);
 
    assert_int_equal(amxb_wait_for_request(request, 5), 0);
    assert_int_equal(amxb_close_request(&request), 0);
    assert_ptr_equal(request, NULL);
 
    assert_int_not_equal(amxb_wait_for_request(request, 5), 0);
 
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    assert_int_equal(amxb_connect(&ctx, "abus://atest:8080/var/run/abus.sock"), 0);
    return_val = 0;
    request = amxb_async_call(ctx, "object", "method", NULL, NULL, NULL);
    assert_non_null(request);
 
    assert_int_equal(amxb_wait_for_request(request, 5), AMXB_ERROR_NOT_SUPPORTED_OP);
    assert_int_equal(amxb_close_request(&request), AMXB_ERROR_NOT_SUPPORTED_OP);
 
    amxb_free(&ctx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be4), 0);
}

test_amxb_async_invoke_and_close()

void test_amxb_async_invoke_and_close

(

UNUSED void **

state

)

Definition at line 299 of file test_amxb_ba_invoke.c.

                                                           {
    amxb_bus_ctx_t* ctx = NULL;
    amxc_var_t args;
    amxb_request_t* request = NULL;
    amxb_invoke_t* invoke_ctx = NULL;
 
    amxc_var_init(&args);
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
    assert_int_equal(amxb_be_register(&dummy_be4), 0);
 
 
    return_val = 0;
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
 
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), return_val);
    assert_ptr_not_equal(request, NULL);
    assert_int_equal(amxb_close_request(&request), 0);
    assert_int_not_equal(amxb_close_request(&request), 0);
 
    assert_int_not_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, NULL), return_val);
    assert_ptr_equal(request, NULL);
 
    assert_int_equal(amxb_async_invoke(invoke_ctx, &args, NULL, NULL, NULL, &request), return_val);
    assert_ptr_not_equal(request, NULL);
    assert_int_equal(amxb_close_request(&request), 0);
    assert_ptr_equal(request, NULL);
 
    amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
    assert_int_equal(amxb_async_invoke(invoke_ctx, &args, NULL, NULL, NULL, &request), return_val);
    assert_ptr_not_equal(request, NULL);
    assert_int_equal(amxb_close_request(&request), 0);
    assert_ptr_equal(request, NULL);
 
    assert_int_not_equal(amxb_async_invoke(NULL, NULL, NULL, NULL, NULL, &request), 0);
    assert_ptr_equal(request, NULL);
 
    return_val = -1;
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), return_val);
    assert_ptr_equal(request, NULL);
 
    return_val = 0;
    amxb_free_invoke(&invoke_ctx);
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_connect(&ctx, "abus://atest:8080/var/run/abus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
 
    return_val = 0;
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), 0);
    assert_ptr_not_equal(request, NULL);
    assert_int_equal(amxb_close_request(&request), AMXB_ERROR_NOT_SUPPORTED_OP);
    assert_ptr_equal(request, NULL);
    assert_int_not_equal(amxb_disconnect(ctx), 0);
    amxb_free_invoke(&invoke_ctx);
    amxb_free(&ctx);
 
    assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
 
    return_val = 0;
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), AMXB_ERROR_NOT_SUPPORTED_OP);
    assert_ptr_equal(request, NULL);
    return_val = -1;
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), AMXB_ERROR_NOT_SUPPORTED_OP);
    assert_ptr_equal(request, NULL);
    return_val = 0;
    amxb_free(&ctx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be4), 0);
    amxc_var_clean(&args);
 
    assert_int_not_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), 0);
    assert_ptr_equal(request, NULL);
    assert_int_not_equal(amxb_close_request(NULL), 0);
    amxb_free_invoke(&invoke_ctx);
}

test_amxb_invoke()

void test_amxb_invoke

(

UNUSED void **

state

)

Definition at line 244 of file test_amxb_ba_invoke.c.

                                           {
    amxb_bus_ctx_t* ctx = NULL;
    amxc_var_t ret;
    amxc_var_t args;
    amxb_invoke_t* invoke_ctx = NULL;
 
    amxc_var_init(&ret);
    amxc_var_init(&args);
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    return_val = 0;
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
 
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, NULL, NULL, NULL, 10), return_val);
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, &ret, NULL, NULL, 10), return_val);
    assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 10), return_val);
    amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
    assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 10), return_val);
    assert_int_not_equal(amxb_invoke(NULL, NULL, NULL, NULL, NULL, 0), 0);
    return_val = -1;
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, NULL, NULL, NULL, 10), return_val);
    return_val = 0;
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free_invoke(&invoke_ctx);
    amxb_free(&ctx);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
 
    return_val = 0;
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, NULL, NULL, NULL, 0), AMXB_ERROR_NOT_SUPPORTED_OP);
    return_val = -1;
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, NULL, NULL, NULL, 0), AMXB_ERROR_NOT_SUPPORTED_OP);
    return_val = 0;
    amxb_free(&ctx);
    amxb_free_invoke(&invoke_ctx);
 
    return_val = 0;
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method()"), 0);
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, NULL, NULL, NULL, 10), return_val);
    assert_int_equal(amxb_invoke(invoke_ctx, NULL, &ret, NULL, NULL, 10), return_val);
    assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 10), return_val);
    amxb_free(&ctx);
    amxb_free_invoke(&invoke_ctx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
    amxc_var_clean(&ret);
    amxc_var_clean(&args);
}

test_amxb_new_free_invoke()

void test_amxb_new_free_invoke

(

UNUSED void **

state

)

Definition at line 200 of file test_amxb_ba_invoke.c.

                                                    {
    amxb_bus_ctx_t* ctx = NULL;
    amxb_invoke_t* invoke_ctx = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    return_val = 0;
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    amxb_free_invoke(&invoke_ctx);
 
    assert_int_not_equal(amxb_new_invoke(NULL, NULL, "object", NULL, "method"), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, NULL, "object", NULL, "method"), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, NULL, NULL, NULL), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, NULL), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "", NULL, ""), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, ""), 0);
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", "interface", "method"), 0);
    assert_string_equal(invoke_ctx->object, "object");
    assert_string_equal(invoke_ctx->interface, "interface");
    assert_string_equal(invoke_ctx->method, "method");
    assert_ptr_equal(invoke_ctx->it.llist, &ctx->invoke_ctxs);
    amxb_free_invoke(&invoke_ctx);
    amxb_free_invoke(&invoke_ctx);
    amxb_free_invoke(NULL);
 
    return_val = -1;
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    assert_ptr_equal(invoke_ctx, NULL);
 
    return_val = 0;
    assert_int_equal(amxb_disconnect(ctx), 0);
    assert_int_not_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    assert_ptr_equal(invoke_ctx, NULL);
 
    amxb_free(&ctx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
}

test_amxb_wait_for_request()

void test_amxb_wait_for_request

(

UNUSED void **

state

)

Definition at line 410 of file test_amxb_ba_invoke.c.

                                                     {
    amxb_bus_ctx_t* ctx = NULL;
    amxb_request_t* request = NULL;
    amxb_invoke_t* invoke_ctx = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be4), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://atest:8080/var/run/xbus.sock"), 0);
    return_val = 0;
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), NULL);
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), 0);
    assert_ptr_not_equal(request, NULL);
 
    assert_int_equal(amxb_wait_for_request(request, 5), 0);
    assert_int_equal(amxb_close_request(&request), 0);
    assert_ptr_equal(request, NULL);
 
    assert_int_not_equal(amxb_wait_for_request(request, 5), 0);
 
    amxb_free_invoke(&invoke_ctx);
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    assert_int_equal(amxb_connect(&ctx, "abus://atest:8080/var/run/abus.sock"), 0);
    return_val = 0;
    assert_int_equal(amxb_new_invoke(&invoke_ctx, ctx, "object", NULL, "method"), 0);
    assert_int_equal(amxb_async_invoke(invoke_ctx, NULL, NULL, NULL, NULL, &request), 0);
    assert_ptr_not_equal(request, NULL);
 
    assert_int_equal(amxb_wait_for_request(request, 5), AMXB_ERROR_NOT_SUPPORTED_OP);
    assert_int_equal(amxb_close_request(&request), AMXB_ERROR_NOT_SUPPORTED_OP);
 
    amxb_free_invoke(&invoke_ctx);
    amxb_free(&ctx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be4), 0);
}

Variable Documentation

dummy_be1

amxb_be_funcs_t dummy_be1

static

Initial value:

= {
    .connect = dummy_connect,
    .disconnect = dummy_disconnect,
    .get_fd = dummy_get_fd,
    .read = dummy_read,
    .new_invoke = dummy_new_invoke,
    .free_invoke = dummy_free_invoke,
    .invoke = dummy_invoke,
    .async_invoke = dummy_async_invoke,
    .wait_request = dummy_wait_request,
    .close_request = dummy_close_request,
    .free = dummy_free,
    .name = "xbus",
    .size = sizeof(amxb_be_funcs_t),
}

Definition at line 167 of file test_amxb_ba_invoke.c.

dummy_be3

amxb_be_funcs_t dummy_be3

static

Initial value:

= {
    .connect = dummy_connect,
    .name = "zbus",
    .size = sizeof(amxb_be_funcs_t),
}

Definition at line 183 of file test_amxb_ba_invoke.c.

dummy_be4

amxb_be_funcs_t dummy_be4

static

Initial value:

= {
    .connect = dummy_connect,
    .async_invoke = dummy_async_invoke,
    .name = "abus",
    .size = sizeof(amxb_be_funcs_t),
}

Definition at line 189 of file test_amxb_ba_invoke.c.

dummy_bus_data

char* dummy_bus_data = "xbus dummy data"

static

Definition at line 79 of file test_amxb_ba_invoke.c.

dummy_ctx

char* dummy_ctx = "xbus"

static

Definition at line 78 of file test_amxb_ba_invoke.c.

return_val

int return_val

static

Definition at line 83 of file test_amxb_ba_invoke.c.

verify_host

char verify_host[64]

static

Definition at line 80 of file test_amxb_ba_invoke.c.

verify_path

char verify_path[64]

static

Definition at line 82 of file test_amxb_ba_invoke.c.

verify_port

char verify_port[64]

static

Definition at line 81 of file test_amxb_ba_invoke.c.