test_amxb_backend_mngr.c File Reference

#include <stdlib.h>
#include <dlfcn.h>
#include <stdarg.h>
#include <stddef.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_backend_mngr.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Macros
#define	ARRAY_SIZE(arr)   (sizeof(arr) / sizeof((arr)[0]))

Functions
void *	__real_dlopen (const char *filename, int flag)
int	__real_dlclose (void *handle)
void *	__wrap_dlopen (const char *filename, int flag)
int	__wrap_dlclose (void *handle)
void *	__wrap_dlsym (void *handle, const char *symbol)
static amxb_be_info_t *	fake_get_version_info ()
static void *	fake_connect (UNUSED const char *host, UNUSED const char *port, UNUSED const char *path, UNUSED amxp_signal_mngr_t *sigmngr)
static int	fake_disconnect (void *ctx)
void *	__wrap_dlopen (UNUSED const char *filename, UNUSED int flag)
int	__wrap_dlclose (UNUSED void *handle)
void *	__wrap_dlsym (UNUSED void *handle, const char *symbol)
void	test_amxb_be_register (UNUSED void **state)
void	test_amxb_be_unregister (UNUSED void **state)
void	test_amxb_be_find (UNUSED void **state)
void	test_amxb_be_load (UNUSED void **state)
void	test_amxb_be_load_same_multiple_times (UNUSED void **state)
void	test_amxb_be_load_multiple (UNUSED void **state)
void	test_amxb_be_remove (UNUSED void **state)
void	test_amxb_be_remove_all (UNUSED void **state)
void	test_amxb_be_load_version_checking (UNUSED void **state)
void	test_amxb_be_get_version (UNUSED void **state)
void	test_amxb_set_config (UNUSED void **state)
void	test_amxb_be_get_info (UNUSED void **state)

Variables
static void *	fake_handle = NULL
static char *	fake_ctx = "fake"
static int	return_val = 0
static uint32_t	min_version_id = 0
static uint32_t	max_version_id = 0
static bool	has_info = true
static bool	register_be = true
static amxb_version_t	sup_min_version []
static amxb_version_t	sup_max_version []
static amxb_version_t	be_version
static amxb_be_info_t	be_info
static amxb_be_funcs_t	dummy_be1
static amxb_be_funcs_t	dummy_be2
static amxb_be_funcs_t	dummy_be3
static amxb_be_funcs_t	dummy_be4
static amxb_be_funcs_t	dummy_be5
static amxb_be_funcs_t	dummy_be6

Macro Definition Documentation

ARRAY_SIZE

#define ARRAY_SIZE

(

arr

)

(sizeof(arr) / sizeof((arr)[0]))

Definition at line 78 of file test_amxb_backend_mngr.c.

Function Documentation

__real_dlclose()

int __real_dlclose

(

void *

handle

)

__real_dlopen()

void* __real_dlopen	(	const char *	filename,
		int	flag
	)

__wrap_dlclose() [1/2]

int __wrap_dlclose

(

UNUSED void *

handle

)

Definition at line 246 of file test_amxb_backend_mngr.c.

                                        {
    return return_val;
}

__wrap_dlclose() [2/2]

int __wrap_dlclose

(

void *

handle

)

__wrap_dlopen() [1/2]

void* __wrap_dlopen	(	const char *	filename,
		int	flag
	)

__wrap_dlopen() [2/2]

void* __wrap_dlopen	(	UNUSED const char *	filename,
		UNUSED int	flag
	)

Definition at line 229 of file test_amxb_backend_mngr.c.

                                                                  {
    if(fake_handle != NULL) {
        if(register_be) {
            if(dummy_be1.handle == NULL) {
                assert_int_equal(amxb_be_register(&dummy_be1), 0);
                assert_ptr_equal(dummy_be1.handle, NULL);
            } else if(dummy_be3.handle == NULL) {
                assert_int_equal(amxb_be_register(&dummy_be3), 0);
                assert_ptr_equal(dummy_be3.handle, NULL);
            } else {
                return NULL;
            }
        }
    }
    return fake_handle;
}

__wrap_dlsym() [1/2]

void* __wrap_dlsym	(	UNUSED void *	handle,
		const char *	symbol
	)

Definition at line 250 of file test_amxb_backend_mngr.c.

                                                            {
    assert_string_equal(symbol, "amxb_be_info");
    if(has_info) {
        return fake_get_version_info;
    } else {
        return NULL;
    }
}

__wrap_dlsym() [2/2]

void* __wrap_dlsym	(	void *	handle,
		const char *	symbol
	)

fake_connect()

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

static

Definition at line 180 of file test_amxb_backend_mngr.c.

                                                              {
    return fake_ctx;
}

fake_disconnect()

static int fake_disconnect ( void *  ctx )

static

Definition at line 187 of file test_amxb_backend_mngr.c.

                                      {
    assert_ptr_equal(ctx, fake_ctx);
    return 0;
}

fake_get_version_info()

static amxb_be_info_t* fake_get_version_info ( )

static

Definition at line 165 of file test_amxb_backend_mngr.c.

                                               {
    if(min_version_id == UINT32_MAX) {
        be_info.min_supported = NULL;
    } else {
        be_info.min_supported = &sup_min_version[min_version_id];
    }
    if(max_version_id == UINT32_MAX) {
        be_info.max_supported = NULL;
    } else {
        be_info.max_supported = &sup_max_version[max_version_id];
    }
 
    return &be_info;
}

test_amxb_be_find()

void test_amxb_be_find

(

UNUSED void **

state

)

Definition at line 290 of file test_amxb_backend_mngr.c.

                                            {
    const amxb_be_funcs_t* funcs = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    funcs = amxb_be_find(NULL);
    assert_ptr_equal(funcs, NULL);
 
    funcs = amxb_be_find("test");
    assert_ptr_equal(funcs, NULL);
 
    funcs = amxb_be_find("");
    assert_ptr_equal(funcs, NULL);
 
    funcs = amxb_be_find("xbus");
    assert_ptr_not_equal(funcs, NULL);
    assert_ptr_equal(funcs, &dummy_be1);
 
    funcs = amxb_be_find("ybus");
    assert_ptr_not_equal(funcs, NULL);
    assert_ptr_equal(funcs, &dummy_be3);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
    assert_ptr_equal(dummy_be3.handle, NULL);
    assert_ptr_equal(dummy_be1.handle, NULL);
}

test_amxb_be_get_info()

void test_amxb_be_get_info

(

UNUSED void **

state

)

Definition at line 554 of file test_amxb_backend_mngr.c.

                                                {
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
    const amxb_be_info_t* info = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
 
    info = amxb_be_get_info("xbus");
    assert_non_null(info);
    info = amxb_be_get_info("test");
    assert_null(info);
    info = amxb_be_get_info("");
    assert_null(info);
    info = amxb_be_get_info(NULL);
    assert_null(info);
 
    amxb_be_remove_all();
 
    info = amxb_be_get_info("xbus");
    assert_null(info);
 
    return_val = 0;
    assert_int_not_equal(amxb_be_unregister(&dummy_be1), 0);
}

test_amxb_be_get_version()

void test_amxb_be_get_version

(

UNUSED void **

state

)

Definition at line 529 of file test_amxb_backend_mngr.c.

                                                   {
    amxb_version_t* libv = (amxb_version_t*) amxb_get_version();
    amxb_version_t* libv2 = NULL;
    assert_ptr_not_equal(libv, NULL);
    assert_int_not_equal(libv->major, 99999);
    libv->major = 99999;
    assert_int_equal(libv->major, 99999);
    libv2 = (amxb_version_t*) amxb_get_version();
    assert_ptr_equal(libv, libv2);
    assert_int_not_equal(libv->major, 99999);
    assert_int_not_equal(libv2->major, 99999);
}

test_amxb_be_load()

void test_amxb_be_load

(

UNUSED void **

state

)

Definition at line 319 of file test_amxb_backend_mngr.c.

                                            {
    const amxb_be_funcs_t* funcs = NULL;
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
 
    min_version_id = 0;
    max_version_id = 1;
    assert_int_not_equal(amxb_be_load(NULL), 0);
    assert_int_not_equal(amxb_be_load(""), 0);
    assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_ptr_equal(dummy_be1.handle, NULL);
 
    funcs = amxb_be_find("xbus");
    assert_ptr_equal(funcs, NULL);
 
    register_be = false;
    assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_ptr_equal(dummy_be1.handle, NULL);
    register_be = true;
 
    fake_handle = NULL;
    assert_int_not_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
}

test_amxb_be_load_multiple()

void test_amxb_be_load_multiple

(

UNUSED void **

state

)

Definition at line 362 of file test_amxb_backend_mngr.c.

                                                     {
    amxc_var_t shared_objects;
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
 
    amxc_var_init(&shared_objects);
 
    min_version_id = 0;
    max_version_id = 1;
 
    assert_int_not_equal(amxb_be_load_multiple(NULL), 0);
    assert_int_not_equal(amxb_be_load_multiple(&shared_objects), 0);
 
    amxc_var_set_type(&shared_objects, AMXC_VAR_ID_CSTRING);
    assert_int_not_equal(amxb_be_load_multiple(&shared_objects), 0);
    amxc_var_set_type(&shared_objects, AMXC_VAR_ID_LIST);
    assert_int_not_equal(amxb_be_load_multiple(&shared_objects), 0);
 
    amxc_var_set(cstring_t, &shared_objects, "/path/to/some/sofile.so");
    assert_int_equal(amxb_be_load_multiple(&shared_objects), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
 
    amxc_var_set_type(&shared_objects, AMXC_VAR_ID_LIST);
    amxc_var_add(cstring_t, &shared_objects, "/path/to/some/sofile1.so");
    amxc_var_add(cstring_t, &shared_objects, "/path/to/some/sofile2.so");
    assert_int_equal(amxb_be_load_multiple(&shared_objects), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_ptr_equal(dummy_be3.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
 
    amxc_var_add(cstring_t, &shared_objects, "/path/to/some/sofile1.so");
    amxc_var_add(cstring_t, &shared_objects, "/path/to/some/sofile2.so");
    amxc_var_add(cstring_t, &shared_objects, "/path/to/some/sofile3.so");
    assert_int_not_equal(amxb_be_load_multiple(&shared_objects), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_ptr_equal(dummy_be3.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
 
    amxc_var_set_type(&shared_objects, AMXC_VAR_ID_CSTRING);
    amxc_var_set(cstring_t, &shared_objects, "/path/to/some/sofile1.so:/path/to/some/sofile2.so");
    assert_int_equal(amxb_be_load_multiple(&shared_objects), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_ptr_equal(dummy_be3.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
 
    amxc_var_set_type(&shared_objects, AMXC_VAR_ID_CSTRING);
    amxc_var_set(cstring_t, &shared_objects, "/path/to/some/sofile1.so:/path/to/some/sofile2.so:/path/to/some/sofile3.so");
    assert_int_not_equal(amxb_be_load_multiple(&shared_objects), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_ptr_equal(dummy_be3.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
 
    amxc_var_clean(&shared_objects);
}

test_amxb_be_load_same_multiple_times()

void test_amxb_be_load_same_multiple_times

(

UNUSED void **

state

)

Definition at line 345 of file test_amxb_backend_mngr.c.

                                                                {
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
 
    register_be = false;
    min_version_id = 0;
    max_version_id = 1;
    assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_ptr_equal(dummy_be1.handle, fake_handle);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_ptr_equal(dummy_be1.handle, NULL);
    register_be = true;
}

test_amxb_be_load_version_checking()

void test_amxb_be_load_version_checking

(

UNUSED void **

state

)

Definition at line 484 of file test_amxb_backend_mngr.c.

                                                             {
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
 
    min_version_id = 0;
    max_version_id = 0;
    for(uint32_t i = 0; i < ARRAY_SIZE(sup_min_version); i++) {
        min_version_id = i;
        if(i < 4) {
            assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
            assert_ptr_equal(dummy_be1.handle, fake_handle);
            assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
        } else {
            assert_int_not_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
            assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
        }
    }
 
    min_version_id = 0;
    max_version_id = 1;
    for(uint32_t i = 0; i < ARRAY_SIZE(sup_min_version); i++) {
        min_version_id = i;
        if(i < 4) {
            assert_int_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
            assert_ptr_equal(dummy_be1.handle, fake_handle);
            assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
        } else {
            assert_int_not_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
            assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
        }
    }
 
    min_version_id = UINT32_MAX;
    assert_int_not_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    min_version_id = 0;
    max_version_id = UINT32_MAX;
    assert_int_not_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    max_version_id = 0;
    has_info = false;
    assert_int_not_equal(amxb_be_load("/path/to/some/sofile.so"), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    has_info = true;
}

test_amxb_be_register()

void test_amxb_be_register

(

UNUSED void **

state

)

Definition at line 259 of file test_amxb_backend_mngr.c.

                                                {
    assert_int_not_equal(amxb_be_register(NULL), 0);
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_not_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_not_equal(amxb_be_register(&dummy_be2), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
    assert_int_not_equal(amxb_be_register(&dummy_be4), 0);
    assert_int_not_equal(amxb_be_register(&dummy_be5), 0);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
    assert_ptr_equal(dummy_be3.handle, NULL);
    assert_ptr_equal(dummy_be1.handle, NULL);
}

test_amxb_be_remove()

void test_amxb_be_remove

(

UNUSED void **

state

)

Definition at line 421 of file test_amxb_backend_mngr.c.

                                              {
    amxb_bus_ctx_t* c1 = NULL;
 
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
 
    min_version_id = 0;
    max_version_id = 1;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    dummy_be1.handle = fake_handle;
 
    assert_int_not_equal(amxb_be_remove(NULL), 0);
    assert_int_not_equal(amxb_be_remove(""), 0);
 
    assert_int_equal(amxb_connect(&c1, "xbus:///var/run/test.sock"), 0);
 
    assert_int_equal(amxb_be_remove("xbus"), 0);
    assert_int_not_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_not_equal(amxb_be_remove("xbus"), 0);
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    dummy_be1.handle = NULL;
    assert_int_not_equal(amxb_be_remove("xbus"), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    dummy_be1.handle = fake_handle;
    return_val = -1;
    assert_int_not_equal(amxb_be_remove("xbus"), 0);
    return_val = 0;
    assert_int_not_equal(amxb_be_unregister(&dummy_be1), 0);
}

test_amxb_be_remove_all()

void test_amxb_be_remove_all

(

UNUSED void **

state

)

Definition at line 454 of file test_amxb_backend_mngr.c.

                                                  {
    fake_handle = __real_dlopen(NULL, RTLD_NOW);
    amxb_bus_ctx_t* c1 = NULL;
    amxb_bus_ctx_t* c2 = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
    dummy_be1.handle = fake_handle;
    dummy_be2.handle = fake_handle;
 
    assert_int_equal(amxb_connect(&c1, "xbus:///var/run/test.sock"), 0);
    assert_int_equal(amxb_connect(&c2, "xbus:///var/run/test.sock"), 0);
 
    amxb_free(&c1);
 
    amxb_be_remove_all();
    assert_int_not_equal(amxb_be_unregister(&dummy_be1), 0);
    dummy_be1.handle = NULL;
    assert_int_not_equal(amxb_be_unregister(&dummy_be3), 0);
    dummy_be3.handle = NULL;
 
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    dummy_be1.handle = fake_handle;
    return_val = -1;
    amxb_be_remove_all();
    return_val = 0;
    assert_int_not_equal(amxb_be_unregister(&dummy_be1), 0);
    dummy_be1.handle = NULL;
}

test_amxb_be_unregister()

void test_amxb_be_unregister

(

UNUSED void **

state

)

Definition at line 274 of file test_amxb_backend_mngr.c.

                                                  {
    assert_int_equal(amxb_be_register(&dummy_be1), 0);
    assert_int_equal(amxb_be_register(&dummy_be3), 0);
 
    assert_int_not_equal(amxb_be_unregister(NULL), 0);
    assert_int_not_equal(amxb_be_unregister(&dummy_be2), 0);
    assert_int_not_equal(amxb_be_unregister(&dummy_be4), 0);
    assert_int_not_equal(amxb_be_unregister(&dummy_be5), 0);
    assert_int_not_equal(amxb_be_unregister(&dummy_be6), 0);
 
    assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
    assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
    assert_ptr_equal(dummy_be3.handle, NULL);
    assert_ptr_equal(dummy_be1.handle, NULL);
}

test_amxb_set_config()

void test_amxb_set_config

(

UNUSED void **

state

)

Definition at line 542 of file test_amxb_backend_mngr.c.

                                               {
    amxc_var_t config;
 
    amxc_var_init(&config);
    amxc_var_set_type(&config, AMXC_VAR_ID_HTABLE);
 
    amxc_var_add_key(amxc_htable_t, &config, "dummy", NULL);
    assert_int_equal(amxb_set_config(&config), 0);
 
    amxc_var_clean(&config);
}

Variable Documentation

be_info

amxb_be_info_t be_info

static

Initial value:

= {
    .be_version = &be_version,
    .name = "dummy",
    .description = "Dummy description",
}

Definition at line 159 of file test_amxb_backend_mngr.c.

be_version

amxb_version_t be_version

static

Initial value:

= {
    .major = 0,
    .minor = 0,
    .build = 7
}

Definition at line 153 of file test_amxb_backend_mngr.c.

dummy_be1

amxb_be_funcs_t dummy_be1

static

Initial value:

= {
    .connect = fake_connect,
    .disconnect = fake_disconnect,
    .size = sizeof(amxb_be_funcs_t),
    .name = "xbus",
}

Definition at line 192 of file test_amxb_backend_mngr.c.

dummy_be2

amxb_be_funcs_t dummy_be2

static

Initial value:

= {
    .connect = NULL,
    .size = sizeof(amxb_be_funcs_t),
    .name = "xbus",
}

Definition at line 199 of file test_amxb_backend_mngr.c.

dummy_be3

amxb_be_funcs_t dummy_be3

static

Initial value:

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

Definition at line 205 of file test_amxb_backend_mngr.c.

dummy_be4

amxb_be_funcs_t dummy_be4

static

Initial value:

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

Definition at line 211 of file test_amxb_backend_mngr.c.

dummy_be5

amxb_be_funcs_t dummy_be5

static

Initial value:

= {
    .connect = NULL,
    .size = sizeof(amxb_be_funcs_t),
    .name = NULL,
}

Definition at line 217 of file test_amxb_backend_mngr.c.

dummy_be6

amxb_be_funcs_t dummy_be6

static

Initial value:

= {
    .connect = NULL,
    .size = sizeof(amxb_be_funcs_t),
    .name = "test",
}

Definition at line 223 of file test_amxb_backend_mngr.c.

fake_ctx

char* fake_ctx = "fake"

static

Definition at line 88 of file test_amxb_backend_mngr.c.

fake_handle

void* fake_handle = NULL

static

Definition at line 87 of file test_amxb_backend_mngr.c.

has_info

bool has_info = true

static

Definition at line 93 of file test_amxb_backend_mngr.c.

max_version_id

uint32_t max_version_id = 0

static

Definition at line 92 of file test_amxb_backend_mngr.c.

min_version_id

uint32_t min_version_id = 0

static

Definition at line 91 of file test_amxb_backend_mngr.c.

register_be

bool register_be = true

static

Definition at line 94 of file test_amxb_backend_mngr.c.

return_val

int return_val = 0

static

Definition at line 89 of file test_amxb_backend_mngr.c.

sup_max_version

amxb_version_t sup_max_version[]

static

Initial value:

= {
    {                               
        .major = 4,
        .minor = 99,
        .build = 999,
    },
    {
        .major = 4,
        .minor = 8,
        .build = 999,
    },
    {
        .major = -1,
    }
}

Definition at line 137 of file test_amxb_backend_mngr.c.

sup_min_version

amxb_version_t sup_min_version[]

static

Definition at line 96 of file test_amxb_backend_mngr.c.