test_amxb_ba_connect.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_connect.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 void *	dummy_accept (UNUSED void *ctx, UNUSED amxp_signal_mngr_t *sigmngr)
static int	dummy_get_fd (void *ctx)
static void	dummy_free (void *ctx)
static int	dummy_read (void *const ctx)
static int	dummy_read_raw (void *const ctx, UNUSED void *buf, UNUSED size_t size)
int	__wrap_dlclose (UNUSED void *handle)
void	test_amxb_connect (UNUSED void **state)
void	test_amxb_listen (UNUSED void **state)
void	test_amxb_accept (UNUSED void **state)
void	test_amxb_disconnect (UNUSED void **state)
void	test_amxb_get_fd (UNUSED void **state)
void	test_amxb_read (UNUSED void **state)
void	test_amxb_find_uris (UNUSED void **state)
void	test_amxb_list_uris (UNUSED void **state)
void	test_amxb_read_raw (UNUSED void **state)

Variables
static char *	dummy_ctx = "xbus"
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_be2
static amxb_be_funcs_t	dummy_be3

Function Documentation

__wrap_dlclose() [1/2]

int __wrap_dlclose

(

UNUSED void *

handle

)

Definition at line 153 of file test_amxb_ba_connect.c.

                                        {
    return 0;
}

__wrap_dlclose() [2/2]

int __wrap_dlclose

(

void *

handle

)

dummy_accept()

static void* dummy_accept ( UNUSED void *  ctx, UNUSED amxp_signal_mngr_t *  sigmngr  )

static

Definition at line 106 of file test_amxb_ba_connect.c.

                                                                                {
    return dummy_ctx;
}

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 86 of file test_amxb_ba_connect.c.

                                                               {
    if(host != NULL) {
        strcpy(verify_host, host);
    }
    if(port != NULL) {
        strcpy(verify_port, port);
    }
    strcpy(verify_path, path);
 
    return dummy_ctx;
}

dummy_disconnect()

static int dummy_disconnect ( void *  ctx )

static

Definition at line 101 of file test_amxb_ba_connect.c.

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

dummy_free()

static void dummy_free ( void *  ctx )

static

Definition at line 115 of file test_amxb_ba_connect.c.

                                  {
    assert_ptr_equal(ctx, dummy_ctx);
}

dummy_get_fd()

static int dummy_get_fd ( void *  ctx )

static

Definition at line 110 of file test_amxb_ba_connect.c.

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

dummy_read()

static int dummy_read ( void *const  ctx )

static

Definition at line 119 of file test_amxb_ba_connect.c.

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

dummy_read_raw()

static int dummy_read_raw ( void *const  ctx, UNUSED void *  buf, UNUSED size_t  size  )

static

Definition at line 124 of file test_amxb_ba_connect.c.

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

test_amxb_accept()

void test_amxb_accept

(

UNUSED void **

state

)

Definition at line 209 of file test_amxb_ba_connect.c.

                                           {
    amxb_bus_ctx_t* lctx = NULL;
    amxb_bus_ctx_t* actx = NULL;
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
 
    dummy_ctx = "xbus";
    assert_int_equal(amxb_listen(&lctx, "xbus:/tmp/test.sock"), 0);
    assert_int_equal(amxb_accept(lctx, &actx), 0);
    assert_ptr_not_equal(actx, NULL);
    assert_int_equal(amxb_disconnect(actx), 0);
    assert_int_equal(amxb_disconnect(lctx), 0);
    amxb_free(&lctx);
    amxb_free(&actx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
}

test_amxb_connect()

void test_amxb_connect

(

UNUSED void **

state

)

Definition at line 157 of file test_amxb_ba_connect.c.

                                            {
    amxb_bus_ctx_t* ctx = NULL;
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be2), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://ipc:[/var/run/test.sock]"), AMXB_ERROR_INVALID_URI);
    assert_int_equal(amxb_connect(&ctx, "rommmel/test"), AMXB_ERROR_INVALID_URI);
    assert_int_equal(amxb_connect(NULL, "xbus://test:80/var/run/xbus.sock"), -1);
    assert_int_equal(amxb_connect(&ctx, "fake://test:80/var/run/fake.sock"), AMXB_ERROR_NOT_SUPPORTED_SCHEME);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_connect(&ctx, "ybus://test:80/var/run/ybus.sock"), AMXB_ERROR_NOT_SUPPORTED_OP);
    assert_ptr_equal(ctx, NULL);
 
    dummy_ctx = NULL;
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), AMXB_ERROR_BACKEND_FAILED);
    dummy_ctx = "xbus";
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_ptr_not_equal(ctx, NULL);
    assert_string_equal(verify_host, "test");
    assert_string_equal(verify_port, "80");
    assert_string_equal(verify_path, "/var/run/xbus.sock");
    assert_int_not_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    ctx = NULL;
    assert_int_not_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
    assert_ptr_equal(ctx, NULL);
    amxb_free(&ctx);
    amxb_free(NULL);
 
    assert_int_equal(amxb_be_unregister(&dummy_be2), 0);
}

test_amxb_disconnect()

void test_amxb_disconnect

(

UNUSED void **

state

)

Definition at line 226 of file test_amxb_ba_connect.c.

                                               {
    amxb_bus_ctx_t* 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_disconnect(NULL), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_ptr_not_equal(ctx, NULL);
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    assert_ptr_equal(ctx, NULL);
    assert_int_not_equal(amxb_disconnect(ctx), 0);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
    assert_ptr_not_equal(ctx, NULL);
    assert_int_not_equal(amxb_disconnect(ctx), 0);
    assert_ptr_not_equal(ctx, NULL);
    amxb_free(&ctx);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
}

test_amxb_find_uris()

void test_amxb_find_uris

(

UNUSED void **

state

)

Definition at line 311 of file test_amxb_ba_connect.c.

                                              {
    amxb_bus_ctx_t* ctx1 = NULL;
    amxb_bus_ctx_t* ctx2 = NULL;
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    assert_int_equal(amxb_connect(&ctx1, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_connect(&ctx2, "zbus://test:80/var/run/zbus.sock"), 0);
 
    assert_ptr_equal(amxb_find_uri("xbus://test:80/var/run/xbus.sock"), ctx1);
    assert_ptr_equal(amxb_find_uri("zbus://test:80/var/run/zbus.sock"), ctx2);
    assert_ptr_equal(amxb_find_uri("ybus://test:80/var/run/ybus.sock"), NULL);
 
    amxb_free(&ctx1);
    amxb_free(&ctx2);
 
    assert_ptr_equal(amxb_find_uri("xbus://test:80/var/run/xbus.sock"), NULL);
    assert_ptr_equal(amxb_find_uri("zbus://test:80/var/run/zbus.sock"), NULL);
    assert_ptr_equal(amxb_find_uri("ybus://test:80/var/run/ybus.sock"), NULL);
 
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
}

test_amxb_get_fd()

void test_amxb_get_fd

(

UNUSED void **

state

)

Definition at line 253 of file test_amxb_ba_connect.c.

                                           {
    amxb_bus_ctx_t* 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_get_fd(NULL), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    return_val = STDIN_FILENO;
    assert_int_equal(amxb_get_fd(ctx), return_val);
    return_val = -1;
    assert_int_equal(amxb_get_fd(ctx), return_val);
    return_val = 0;
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    return_val = 0;
    assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
    return_val = STDIN_FILENO;
    assert_int_equal(amxb_get_fd(ctx), -1);
    return_val = 0;
    assert_int_not_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    return_val = 0;
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
}

test_amxb_list_uris()

void test_amxb_list_uris

(

UNUSED void **

state

)

Definition at line 336 of file test_amxb_ba_connect.c.

                                              {
    amxb_bus_ctx_t* ctx1 = NULL;
    amxb_bus_ctx_t* ctx2 = NULL;
    amxc_array_t* array = NULL;
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    assert_int_equal(amxb_connect(&ctx1, "xbus://test:80/var/run/xbus.sock"), 0);
    assert_int_equal(amxb_connect(&ctx2, "zbus://test:80/var/run/zbus.sock"), 0);
 
    array = amxb_list_uris();
    assert_int_equal(amxc_array_size(array), 2);
    amxc_array_delete(&array, NULL);
 
    amxb_free(&ctx1);
    amxb_free(&ctx2);
 
    array = amxb_list_uris();
    assert_int_equal(amxc_array_size(array), 0);
    amxc_array_delete(&array, NULL);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
}

test_amxb_listen()

void test_amxb_listen

(

UNUSED void **

state

)

Definition at line 195 of file test_amxb_ba_connect.c.

                                           {
    amxb_bus_ctx_t* ctx = NULL;
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
 
    dummy_ctx = "xbus";
    assert_int_equal(amxb_listen(&ctx, "xbus:/tmp/test.sock"), 0);
    assert_ptr_not_equal(ctx, NULL);
    assert_string_equal(verify_path, "/tmp/test.sock");
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
}

test_amxb_read()

void test_amxb_read

(

UNUSED void **

state

)

Definition at line 282 of file test_amxb_ba_connect.c.

                                         {
    amxb_bus_ctx_t* ctx = NULL;
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    return_val = 0;
    assert_int_equal(amxb_read(ctx), return_val);
    return_val = -1;
    assert_int_equal(amxb_read(ctx), return_val);
    return_val = 0;
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
    return_val = 0;
    assert_int_equal(amxb_read(ctx), -1);
    return_val = -1;
    assert_int_equal(amxb_read(ctx), -1);
    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_not_equal(amxb_read(NULL), 0);
}

test_amxb_read_raw()

void test_amxb_read_raw

(

UNUSED void **

state

)

Definition at line 361 of file test_amxb_ba_connect.c.

                                             {
    amxb_bus_ctx_t* ctx = NULL;
    char* buffer[100];
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
    return_val = 100;
    assert_int_equal(amxb_read_raw(ctx, buffer, 100), return_val);
    assert_int_equal(amxb_read_raw(ctx, NULL, 100), -1);
    assert_int_equal(amxb_read_raw(ctx, buffer, 0), -1);
    return_val = -1;
    assert_int_equal(amxb_read_raw(ctx, buffer, 100), return_val);
    return_val = 0;
    assert_int_equal(amxb_disconnect(ctx), 0);
    amxb_free(&ctx);
    assert_ptr_equal(ctx, NULL);
 
    assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
    return_val = 0;
    assert_int_equal(amxb_read_raw(ctx, buffer, 100), -1);
    return_val = -1;
    assert_int_equal(amxb_read_raw(ctx, buffer, 100), -1);
    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_read_raw(NULL, buffer, 100), -1);
}

Variable Documentation

dummy_be1

amxb_be_funcs_t dummy_be1

static

Initial value:

= {
    .connect = dummy_connect,
    .disconnect = dummy_disconnect,
    .listen = dummy_connect,
    .accept = dummy_accept,
    .get_fd = dummy_get_fd,
    .read = dummy_read,
    .read_raw = dummy_read_raw,
    .free = dummy_free,
    .name = "xbus",
    .size = sizeof(amxb_be_funcs_t),
}

Definition at line 129 of file test_amxb_ba_connect.c.

dummy_be2

amxb_be_funcs_t dummy_be2

static

Initial value:

= {
    .size = sizeof(amxb_be_funcs_t),
    .name = "ybus",
}

Definition at line 142 of file test_amxb_ba_connect.c.

dummy_be3

amxb_be_funcs_t dummy_be3

static

Initial value:

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

Definition at line 147 of file test_amxb_ba_connect.c.

dummy_ctx

char* dummy_ctx = "xbus"

static

Definition at line 78 of file test_amxb_ba_connect.c.

return_val

int return_val

static

Definition at line 82 of file test_amxb_ba_connect.c.

verify_host

char verify_host[64]

static

Definition at line 79 of file test_amxb_ba_connect.c.

verify_path

char verify_path[64]

static

Definition at line 81 of file test_amxb_ba_connect.c.

verify_port

char verify_port[64]

static

Definition at line 80 of file test_amxb_ba_connect.c.