Amxb_Ubus  3.3.1
Ambiorix Ubus API
Macros | Functions
test_amxb_ubus_invoke.h File Reference
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Macros

#define __TEST_AMXB_UBUS_INVOKE_H__
 

Functions

int test_amxb_ubus_invoke_amx_setup (UNUSED void **state)
 
int test_amxb_ubus_invoke_amx_teardown (UNUSED void **state)
 
void test_ubus_can_call_function (UNUSED void **state)
 
void test_ubus_invoke_with_cb_function (UNUSED void **state)
 
void test_ubus_async_invoke (UNUSED void **state)
 
void test_ubus_call_non_existing_function (UNUSED void **state)
 
void test_ubus_call_non_existing_function_async (void **state)
 
void test_ubus_call_function_non_existing_path (UNUSED void **state)
 
void test_ubus_call_using_index_path (UNUSED void **state)
 
void test_ubus_call_using_key_path (UNUSED void **state)
 
void test_ubus_can_call_amx_function (UNUSED void **state)
 
void test_ubus_invoke_amx_with_cb_function (UNUSED void **state)
 
void test_ubus_async_amx_invoke (UNUSED void **state)
 
void test_ubus_call_amx_using_index_path (UNUSED void **state)
 
void test_ubus_call_amx_using_key_path (UNUSED void **state)
 
void test_ubus_invoke_amx_with_cb_function_on_non_existing_path (void **state)
 

Macro Definition Documentation

◆ __TEST_AMXB_UBUS_INVOKE_H__

#define __TEST_AMXB_UBUS_INVOKE_H__

Definition at line 56 of file test_amxb_ubus_invoke.h.

Function Documentation

◆ test_amxb_ubus_invoke_amx_setup()

int test_amxb_ubus_invoke_amx_setup ( UNUSED void **  state)

Definition at line 89 of file test_amxb_ubus_invoke.c.

89  {
90  amxc_string_t txt;
91  const char* ubus_sock = test_amxb_ubus_get_socket();
92  printf("Ubus socket = %s\n", ubus_sock);
93 
94  amxc_string_init(&txt, 0);
95 
96  amxc_string_reset(&txt);
97  amxc_string_setf(&txt, "amxrt -u ubus: -B ../mod-amxb-test-ubus.so -A ../test_data/test_nemo.odl &");
98  system(amxc_string_get(&txt, 0));
99  amxc_string_setf(&txt, "amxrt -u ubus: -B ../mod-amxb-test-ubus.so -A ../test_data/test_full_types.odl &");
100  system(amxc_string_get(&txt, 0));
101 
102  amxc_string_clean(&txt);
103 
104  assert_int_equal(amxb_be_load("../mod-amxb-test-ubus.so"), 0);
105  assert_int_equal(amxb_connect(&bus_ctx, ubus_sock), 0);
106 
107  sleep(1);
108 
109  return 0;
110 }
test_amxb_ubus_get_socket
static const char * test_amxb_ubus_get_socket(void)
Definition: test_amxb_ubus_invoke.c:78
bus_ctx
static amxb_bus_ctx_t * bus_ctx
Definition: test_amxb_ubus_invoke.c:76
Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_amxb_ubus_invoke_amx_teardown()

int test_amxb_ubus_invoke_amx_teardown ( UNUSED void **  state)

Definition at line 112 of file test_amxb_ubus_invoke.c.

112  {
113  amxb_disconnect(bus_ctx);
114  amxb_free(&bus_ctx);
115 
116  system("killall amxrt");
117 
118  amxb_be_remove_all();
119  unlink("test_config.odl");
120 
121  return 0;
122 }
Here is the caller graph for this function:

◆ test_ubus_async_amx_invoke()

void test_ubus_async_amx_invoke ( UNUSED void **  state)

Definition at line 219 of file test_amxb_ubus_invoke.c.

219  {
220  amxc_var_t args;
221  amxb_invoke_t* invoke_ctx = NULL;
222  amxb_request_t* req = NULL;
223 
224  amxc_var_init(&args);
225 
226  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "_get"), AMXB_STATUS_OK);
227  assert_int_equal(amxb_async_invoke(invoke_ctx, &args, test_ubus_invoke_cb, test_ubus_invoke_done_cb, NULL, &req), AMXB_STATUS_OK);
228  amxb_free_invoke(&invoke_ctx);
229  amxb_close_request(&req);
230 
231  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "_get"), AMXB_STATUS_OK);
232  assert_int_equal(amxb_async_invoke(invoke_ctx, &args, test_ubus_invoke_cb, test_ubus_invoke_done_cb, NULL, &req), AMXB_STATUS_OK);
233  assert_int_equal(amxb_wait_for_request(req, 5), AMXB_STATUS_OK);
234  amxb_free_invoke(&invoke_ctx);
235  amxb_close_request(&req);
236 
237  amxc_var_clean(&args);
238 }
test_ubus_invoke_done_cb
static void test_ubus_invoke_done_cb(UNUSED const amxb_bus_ctx_t *bus_ctx, UNUSED amxb_request_t *req, UNUSED int status, UNUSED void *priv)
Definition: test_amxb_ubus_invoke.c:146
test_ubus_invoke_cb
static void test_ubus_invoke_cb(UNUSED const amxb_bus_ctx_t *bus_ctx, UNUSED const amxc_var_t *const data, UNUSED void *priv)
Definition: test_amxb_ubus_invoke.c:140
Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_ubus_async_invoke()

void test_ubus_async_invoke ( UNUSED void **  state)

Definition at line 192 of file test_amxb_ubus_invoke.c.

192  {
193  amxc_var_t args;
194  amxb_invoke_t* invoke_ctx = NULL;
195  amxb_request_t* req = NULL;
196 
197  amxc_var_init(&args);
198 
199  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "get"), AMXB_STATUS_OK);
200  assert_int_equal(amxb_async_invoke(invoke_ctx, &args, test_ubus_invoke_cb, test_ubus_invoke_done_cb, NULL, &req), AMXB_STATUS_OK);
201  amxb_free_invoke(&invoke_ctx);
202  amxb_close_request(&req);
203 
204  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "get"), AMXB_STATUS_OK);
205  assert_int_equal(amxb_async_invoke(invoke_ctx, &args, test_ubus_invoke_cb, test_ubus_invoke_done_cb, NULL, &req), AMXB_STATUS_OK);
206  assert_int_equal(amxb_wait_for_request(req, 5), AMXB_STATUS_OK);
207  amxb_free_invoke(&invoke_ctx);
208  amxb_close_request(&req);
209 
210  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "TestObject.", NULL, "get"), AMXB_STATUS_OK);
211  assert_int_equal(amxb_async_invoke(invoke_ctx, &args, test_ubus_invoke_cb, test_ubus_invoke_done_cb, NULL, &req), AMXB_STATUS_OK);
212  assert_int_equal(amxb_wait_for_request(req, 5), AMXB_STATUS_OK);
213  amxb_free_invoke(&invoke_ctx);
214  amxb_close_request(&req);
215 
216  amxc_var_clean(&args);
217 }
Here is the call graph for this function:

◆ test_ubus_call_amx_using_index_path()

void test_ubus_call_amx_using_index_path ( UNUSED void **  state)

Definition at line 293 of file test_amxb_ubus_invoke.c.

293  {
294  amxc_var_t args;
295  amxc_var_t ret;
296  amxb_invoke_t* invoke_ctx = NULL;
297  const char* path = "NeMo.Intf.1.Query.100.";
298 
299  amxc_var_init(&args);
300  amxc_var_init(&ret);
301 
302  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, path, NULL, "_get"), AMXB_STATUS_OK);
303  assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 5), AMXB_STATUS_OK);
304  amxc_var_dump(&ret, STDOUT_FILENO);
305  amxb_free_invoke(&invoke_ctx);
306 
307  amxc_var_clean(&args);
308  amxc_var_clean(&ret);
309 }
Here is the caller graph for this function:

◆ test_ubus_call_amx_using_key_path()

void test_ubus_call_amx_using_key_path ( UNUSED void **  state)

Definition at line 311 of file test_amxb_ubus_invoke.c.

311  {
312  amxc_var_t args;
313  amxc_var_t ret;
314  amxb_invoke_t* invoke_ctx = NULL;
315 
316  amxc_var_init(&args);
317  amxc_var_init(&ret);
318 
319  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.Query.SomeKey.", NULL, "_get"), AMXB_STATUS_OK);
320  assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 5), AMXB_STATUS_OK);
321  amxc_var_dump(&ret, STDOUT_FILENO);
322  amxb_free_invoke(&invoke_ctx);
323 
324  amxc_var_clean(&args);
325  amxc_var_clean(&ret);
326 }
Here is the caller graph for this function:

◆ test_ubus_call_function_non_existing_path()

void test_ubus_call_function_non_existing_path ( UNUSED void **  state)

Definition at line 277 of file test_amxb_ubus_invoke.c.

277  {
278  amxc_var_t args;
279  amxc_var_t ret;
280  amxb_invoke_t* invoke_ctx = NULL;
281 
282  amxc_var_init(&args);
283  amxc_var_init(&ret);
284 
285  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.XDSL.NonExisting.", NULL, "_get"), AMXB_STATUS_OK);
286  assert_int_not_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 5), AMXB_STATUS_OK);
287  amxc_var_dump(&ret, STDOUT_FILENO);
288  amxb_free_invoke(&invoke_ctx);
289  amxc_var_clean(&args);
290  amxc_var_clean(&ret);
291 }
Here is the caller graph for this function:

◆ test_ubus_call_non_existing_function()

void test_ubus_call_non_existing_function ( UNUSED void **  state)

Definition at line 241 of file test_amxb_ubus_invoke.c.

241  {
242  amxc_var_t args;
243  amxc_var_t ret;
244  amxb_invoke_t* invoke_ctx = NULL;
245 
246  amxc_var_init(&args);
247  amxc_var_init(&ret);
248 
249  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "dummy"), AMXB_STATUS_OK);
250  assert_int_not_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 5), AMXB_STATUS_OK);
251  amxc_var_dump(&ret, STDOUT_FILENO);
252  amxb_free_invoke(&invoke_ctx);
253  amxc_var_clean(&args);
254  amxc_var_clean(&ret);
255 }
Here is the caller graph for this function:

◆ test_ubus_call_non_existing_function_async()

void test_ubus_call_non_existing_function_async ( void **  state)

◆ test_ubus_call_using_index_path()

void test_ubus_call_using_index_path ( UNUSED void **  state)

◆ test_ubus_call_using_key_path()

void test_ubus_call_using_key_path ( UNUSED void **  state)

◆ test_ubus_can_call_amx_function()

void test_ubus_can_call_amx_function ( UNUSED void **  state)

Definition at line 124 of file test_amxb_ubus_invoke.c.

124  {
125  amxc_var_t args;
126  amxc_var_t ret;
127  amxb_invoke_t* invoke_ctx = NULL;
128 
129  amxc_var_init(&args);
130  amxc_var_init(&ret);
131 
132  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "_get"), AMXB_STATUS_OK);
133  assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, NULL, NULL, 5), AMXB_STATUS_OK);
134  amxc_var_dump(&ret, STDOUT_FILENO);
135  amxb_free_invoke(&invoke_ctx);
136  amxc_var_clean(&args);
137  amxc_var_clean(&ret);
138 }
Here is the caller graph for this function:

◆ test_ubus_can_call_function()

void test_ubus_can_call_function ( UNUSED void **  state)

◆ test_ubus_invoke_amx_with_cb_function()

void test_ubus_invoke_amx_with_cb_function ( UNUSED void **  state)

Definition at line 170 of file test_amxb_ubus_invoke.c.

170  {
171  amxc_var_t args;
172  amxc_var_t ret;
173  amxb_invoke_t* invoke_ctx = NULL;
174 
175  amxc_var_init(&args);
176  amxc_var_init(&ret);
177 
178  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "_get"), AMXB_STATUS_OK);
179  assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, test_ubus_invoke_cb, NULL, 5), AMXB_STATUS_OK);
180  amxc_var_dump(&ret, STDOUT_FILENO);
181  amxb_free_invoke(&invoke_ctx);
182 
183  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "TestObject.", NULL, "_get"), AMXB_STATUS_OK);
184  assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, test_ubus_invoke_cb, NULL, 5), AMXB_STATUS_OK);
185  amxc_var_dump(&ret, STDOUT_FILENO);
186  amxb_free_invoke(&invoke_ctx);
187 
188  amxc_var_clean(&args);
189  amxc_var_clean(&ret);
190 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_ubus_invoke_amx_with_cb_function_on_non_existing_path()

void test_ubus_invoke_amx_with_cb_function_on_non_existing_path ( void **  state)

◆ test_ubus_invoke_with_cb_function()

void test_ubus_invoke_with_cb_function ( UNUSED void **  state)

Definition at line 153 of file test_amxb_ubus_invoke.c.

153  {
154  amxc_var_t args;
155  amxc_var_t ret;
156  amxb_invoke_t* invoke_ctx = NULL;
157 
158  amxc_var_init(&args);
159  amxc_var_init(&ret);
160 
161  assert_int_equal(amxb_new_invoke(&invoke_ctx, bus_ctx, "NeMo.Intf.lan.", NULL, "get"), AMXB_STATUS_OK);
162  assert_int_equal(amxb_invoke(invoke_ctx, &args, &ret, test_ubus_invoke_cb, NULL, 5), AMXB_STATUS_OK);
163  amxc_var_dump(&ret, STDOUT_FILENO);
164  amxb_free_invoke(&invoke_ctx);
165 
166  amxc_var_clean(&args);
167  amxc_var_clean(&ret);
168 }
Here is the call graph for this function: