libamxb  4.8.2
Bus Agnostic C API
Functions | Variables
test_amxb_ba_subscribe.c File Reference
#include <stdlib.h>
#include <stdio.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_subscribe.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

int __wrap_dlclose (void *handle)
 
static void handle_events (void)
 
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_describe (void *const ctx, const char *object, UNUSED const char *search_path, UNUSED uint32_t flags, UNUSED uint32_t access, amxc_var_t *values, UNUSED int timeout)
 
static int dummy_subscribe (void *const ctx, UNUSED const char *object)
 
static int dummy_unsubscribe (void *const ctx, UNUSED const char *object)
 
int __wrap_dlclose (UNUSED void *handle)
 
static void dummy_notify_handler (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
static void dummy_notify_handler2 (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
void test_amxb_subscribe (UNUSED void **state)
 
void test_amxb_subscribe_invalid_path (UNUSED void **state)
 
void test_amxb_subscribe_should_not_segfault (UNUSED void **state)
 
void test_amxb_unsubscribe (UNUSED void **state)
 
void test_amxb_subscription_new (UNUSED void **state)
 
static void test_wait_done (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, void *const priv)
 
void test_amxb_wait_for (UNUSED void **state)
 
void test_amxb_subscription_find (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 const char * sub_obj = NULL
 
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 188 of file test_amxb_ba_subscribe.c.

188  {
189  return 0;
190 }

◆ __wrap_dlclose() [2/2]

int __wrap_dlclose ( void *  handle)

◆ 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 96 of file test_amxb_ba_subscribe.c.

99  {
100  strcpy(verify_host, host);
101  strcpy(verify_port, port);
102  strcpy(verify_path, path);
103 
104  return dummy_ctx;
105 }
verify_port
static char verify_port[64]
Definition: test_amxb_ba_subscribe.c:81
verify_host
static char verify_host[64]
Definition: test_amxb_ba_subscribe.c:80
verify_path
static char verify_path[64]
Definition: test_amxb_ba_subscribe.c:82
dummy_ctx
static char * dummy_ctx
Definition: test_amxb_ba_subscribe.c:79

◆ dummy_describe()

static int dummy_describe ( void *const  ctx,
const char *  object,
UNUSED const char *  search_path,
UNUSED uint32_t  flags,
UNUSED uint32_t  access,
amxc_var_t *  values,
UNUSED int  timeout 
)
static

Definition at line 126 of file test_amxb_ba_subscribe.c.

132  {
133  assert_ptr_equal(ctx, dummy_ctx);
134  amxc_var_set_type(values, AMXC_VAR_ID_LIST);
135  amxc_var_t* obj_data = amxc_var_add(amxc_htable_t, values, NULL);
136 
137  amxc_string_t path;
138  amxc_string_init(&path, 0);
139  amxc_string_setf(&path, "%s%s", object, search_path);
140 
141  amxc_var_add_key(cstring_t, obj_data, "path", amxc_string_get(&path, 0));
142  amxc_var_dump(values, STDOUT_FILENO);
143  fflush(stdout);
144 
145  amxc_string_clean(&path);
146  return 0;
147 }

◆ dummy_disconnect()

static int dummy_disconnect ( void *  ctx)
static

Definition at line 107 of file test_amxb_ba_subscribe.c.

107  {
108  assert_ptr_equal(ctx, dummy_ctx);
109  return return_val;
110 }
return_val
static int return_val
Definition: test_amxb_ba_subscribe.c:83

◆ dummy_free()

static void dummy_free ( void *  ctx)
static

Definition at line 117 of file test_amxb_ba_subscribe.c.

117  {
118  assert_ptr_equal(ctx, dummy_ctx);
119 }

◆ dummy_get_fd()

static int dummy_get_fd ( void *  ctx)
static

Definition at line 112 of file test_amxb_ba_subscribe.c.

112  {
113  assert_ptr_equal(ctx, dummy_ctx);
114  return return_val;
115 }

◆ dummy_notify_handler()

static void dummy_notify_handler ( UNUSED const char *const  sig_name,
UNUSED const amxc_var_t *const  data,
UNUSED void *const  priv 
)
static

Definition at line 192 of file test_amxb_ba_subscribe.c.

194  {
195  return;
196 }

◆ dummy_notify_handler2()

static void dummy_notify_handler2 ( UNUSED const char *const  sig_name,
UNUSED const amxc_var_t *const  data,
UNUSED void *const  priv 
)
static

Definition at line 198 of file test_amxb_ba_subscribe.c.

200  {
201  return;
202 }

◆ dummy_read()

static int dummy_read ( void *const  ctx)
static

Definition at line 121 of file test_amxb_ba_subscribe.c.

121  {
122  assert_ptr_equal(ctx, dummy_ctx);
123  return return_val;
124 }

◆ dummy_subscribe()

static int dummy_subscribe ( void *const  ctx,
UNUSED const char *  object 
)
static

Definition at line 149 of file test_amxb_ba_subscribe.c.

150  {
151  assert_ptr_equal(ctx, dummy_ctx);
152  return return_val;
153 }

◆ dummy_unsubscribe()

static int dummy_unsubscribe ( void *const  ctx,
UNUSED const char *  object 
)
static

Definition at line 155 of file test_amxb_ba_subscribe.c.

156  {
157  assert_ptr_equal(ctx, dummy_ctx);
158  return return_val;
159 }

◆ handle_events()

static void handle_events ( void  )
static

Definition at line 88 of file test_amxb_ba_subscribe.c.

88  {
89  printf("Handling events ");
90  while(amxp_signal_read() == 0) {
91  printf(".");
92  }
93  printf("\n");
94 }

◆ test_amxb_subscribe()

void test_amxb_subscribe ( UNUSED void **  state)

Definition at line 204 of file test_amxb_ba_subscribe.c.

204  {
205  amxb_bus_ctx_t* ctx = NULL;
206 
207  assert_int_equal(amxb_be_register(&dummy_be1), 0);
208  assert_int_equal(amxb_be_register(&dummy_be3), 0);
209 
210  return_val = 0;
211  sub_obj = "object";
212  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
213  assert_int_not_equal(amxb_subscribe(ctx, "object", NULL, NULL, NULL), return_val);
214  assert_int_not_equal(amxb_subscribe(ctx, NULL, NULL, NULL, NULL), return_val);
215  assert_int_not_equal(amxb_subscribe(NULL, NULL, NULL, NULL, NULL), return_val);
216  assert_int_equal(amxb_subscribe(ctx, "object", NULL, dummy_notify_handler, NULL), return_val);
217  assert_int_equal(amxb_subscribe(ctx, "object", NULL, dummy_notify_handler, NULL), return_val);
218  assert_int_equal(amxb_unsubscribe(ctx, "object", dummy_notify_handler, NULL), return_val);
219  assert_int_equal(amxb_subscribe(ctx, "object.*.", NULL, dummy_notify_handler, NULL), return_val);
220  assert_int_equal(amxb_unsubscribe(ctx, "object.*.", dummy_notify_handler, NULL), return_val);
221  return_val = -1;
222  sub_obj = "other_object";
223  assert_int_equal(amxb_subscribe(ctx, "other_object", NULL, dummy_notify_handler, NULL), return_val);
224  return_val = 0;
225  assert_int_equal(amxb_disconnect(ctx), return_val);
226  assert_int_not_equal(amxb_subscribe(ctx, "other_object", NULL, dummy_notify_handler, NULL), return_val);
227  amxb_free(&ctx);
228 
229  return_val = 0;
230  assert_int_not_equal(amxb_subscribe(ctx, "other_object", NULL, dummy_notify_handler, NULL), return_val);
231 
232  assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
233  assert_int_equal(amxb_subscribe(ctx, "object", NULL, dummy_notify_handler, NULL), AMXB_ERROR_NOT_SUPPORTED_OP);
234  amxb_free(&ctx);
235 
236  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
237  assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
238 }
amxb_be_unregister
int amxb_be_unregister(amxb_be_funcs_t *const funcs)
Unregisters a backend interface.
Definition: amxb_backend_mngr.c:406
amxb_be_register
int amxb_be_register(amxb_be_funcs_t *const funcs)
Registers backend interface.
Definition: amxb_backend_mngr.c:372
amxb_connect
int amxb_connect(amxb_bus_ctx_t **ctx, const char *uri)
Create a bus connection.
Definition: amxb_ba_connect.c:235
amxb_free
void amxb_free(amxb_bus_ctx_t **ctx)
Frees allocated memory.
Definition: amxb_ba_connect.c:339
amxb_disconnect
int amxb_disconnect(amxb_bus_ctx_t *ctx)
Disconnects a bus connection.
Definition: amxb_ba_connect.c:303
AMXB_ERROR_NOT_SUPPORTED_OP
#define AMXB_ERROR_NOT_SUPPORTED_OP
Function/operation not supported.
Definition: amxb_error.h:110
amxb_unsubscribe
int amxb_unsubscribe(amxb_bus_ctx_t *const ctx, const char *object, amxp_slot_fn_t slot_cb, void *priv)
Removes an event subscription.
Definition: amxb_ba_subscribe.c:274
amxb_subscribe
int amxb_subscribe(amxb_bus_ctx_t *const ctx, const char *object, const char *expression, amxp_slot_fn_t slot_cb, void *priv)
Subscribes for events of a object tree.
Definition: amxb_ba_subscribe.c:205
_amxb_bus_ctx
Definition: amxb_types.h:115
dummy_be1
static amxb_be_funcs_t dummy_be1
Definition: test_amxb_ba_subscribe.c:161
dummy_be3
static amxb_be_funcs_t dummy_be3
Definition: test_amxb_ba_subscribe.c:174
sub_obj
static const char * sub_obj
Definition: test_amxb_ba_subscribe.c:84
dummy_notify_handler
static void dummy_notify_handler(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_amxb_ba_subscribe.c:192

◆ test_amxb_subscribe_invalid_path()

void test_amxb_subscribe_invalid_path ( UNUSED void **  state)

Definition at line 240 of file test_amxb_ba_subscribe.c.

240  {
241  amxb_bus_ctx_t* ctx = NULL;
242 
243  assert_int_equal(amxb_be_register(&dummy_be1), 0);
244  assert_int_equal(amxb_be_register(&dummy_be3), 0);
245 
246  return_val = 0;
247  sub_obj = "object";
248  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
249  assert_int_not_equal(amxb_subscribe(ctx, "object.parameter+", NULL, dummy_notify_handler, NULL), return_val);
250  assert_int_not_equal(amxb_subscribe(ctx, "object.parameter[testing].", NULL, dummy_notify_handler, NULL), return_val);
251  assert_int_not_equal(amxb_subscribe(ctx, "object.{i}.", NULL, dummy_notify_handler, NULL), return_val);
252  assert_int_not_equal(amxb_unsubscribe(ctx, "object.parameter+", dummy_notify_handler, NULL), return_val);
253  assert_int_not_equal(amxb_unsubscribe(ctx, "object.parameter[testing].", dummy_notify_handler, NULL), return_val);
254  assert_int_not_equal(amxb_unsubscribe(ctx, "object.{i}.", dummy_notify_handler, NULL), return_val);
255  assert_int_equal(amxb_disconnect(ctx), return_val);
256  amxb_free(&ctx);
257 
258  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
259  assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
260 }

◆ test_amxb_subscribe_should_not_segfault()

void test_amxb_subscribe_should_not_segfault ( UNUSED void **  state)

Definition at line 262 of file test_amxb_ba_subscribe.c.

262  {
263  amxb_bus_ctx_t* ctx = NULL;
264 
265  assert_int_equal(amxb_be_register(&dummy_be1), 0);
266 
267  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
268  sub_obj = "myroot.some_object.some_other";
269  return_val = 0;
270  assert_int_equal(amxb_subscribe(ctx, "myroot.some_object.some_other.", NULL, dummy_notify_handler, NULL), return_val);
271  assert_int_equal(amxb_unsubscribe(ctx, "myroot.some_object.some_other.", dummy_notify_handler, NULL), return_val);
272 
273  amxb_free(&ctx);
274 
275  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
276 }

◆ test_amxb_subscription_find()

void test_amxb_subscription_find ( UNUSED void **  state)

Definition at line 396 of file test_amxb_ba_subscribe.c.

396  {
397  amxb_bus_ctx_t* ctx = NULL;
398  amxb_subscription_t* sub1 = NULL;
399  amxb_subscription_t* sub2 = NULL;
400  amxb_subscription_t* fsub = NULL;
401 
402  assert_int_equal(amxb_be_register(&dummy_be1), 0);
403 
404  return_val = 0;
405  sub_obj = "object";
406  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
407 
408  assert_int_equal(amxb_subscription_new(&sub1, ctx, "object.", NULL, dummy_notify_handler, NULL), return_val);
409  assert_non_null(sub1);
410  assert_int_equal(amxb_subscription_new(&sub2, ctx, "object.subobject.", NULL, dummy_notify_handler, NULL), return_val);
411  assert_non_null(sub2);
412 
413  fsub = amxb_subscription_find_child(ctx, "object.");
414  assert_non_null(fsub);
415  assert_ptr_equal(sub2, fsub);
416 
417  fsub = amxb_subscription_find_parent(ctx, "object.subobject.");
418  assert_non_null(fsub);
419  assert_ptr_equal(sub1, fsub);
420 
421  fsub = amxb_subscription_find_parent(ctx, "test.subobject.");
422  assert_null(fsub);
423 
424  fsub = amxb_subscription_find_child(ctx, "test.");
425  assert_null(fsub);
426 
427  fsub = amxb_subscription_find_child(ctx, NULL);
428  assert_null(fsub);
429 
430  fsub = amxb_subscription_find_parent(ctx, "");
431  assert_null(fsub);
432 
433  assert_int_equal(amxb_subscription_delete(&sub1), 0);
434  assert_int_equal(amxb_subscription_delete(&sub2), 0);
435 
436  assert_int_equal(amxb_disconnect(ctx), return_val);
437  amxb_free(&ctx);
438 
439  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
440 }
amxb_subscription_find_child
amxb_subscription_t * amxb_subscription_find_child(amxb_bus_ctx_t *bus_ctx, const char *object)
Find a child subscription.
Definition: amxb_subscription.c:245
amxb_subscription_delete
int amxb_subscription_delete(amxb_subscription_t **subscription)
Deletes a subscription object and unsubscribe for events of a object tree.
Definition: amxb_subscription.c:250
amxb_subscription_find_parent
amxb_subscription_t * amxb_subscription_find_parent(amxb_bus_ctx_t *bus_ctx, const char *object)
Find a parent subscription.
Definition: amxb_subscription.c:240
amxb_subscription_new
int amxb_subscription_new(amxb_subscription_t **subscription, amxb_bus_ctx_t *bus_ctx, const char *object, const char *expression, amxp_slot_fn_t slot_cb, void *priv)
Creates a subscription object and subscribes for events of a object tree.
Definition: amxb_subscription.c:187
_amxb_subscription
Definition: amxb_types.h:157

◆ test_amxb_subscription_new()

void test_amxb_subscription_new ( UNUSED void **  state)

Definition at line 321 of file test_amxb_ba_subscribe.c.

321  {
322  amxb_bus_ctx_t* ctx = NULL;
323  amxb_subscription_t* sub = NULL;
324  amxb_subscription_t* fsub = NULL;
325 
326  assert_int_equal(amxb_be_register(&dummy_be1), 0);
327  assert_int_equal(amxb_be_register(&dummy_be3), 0);
328 
329  return_val = 0;
330  sub_obj = "object";
331  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
332  assert_int_equal(amxb_subscription_new(&sub, ctx, "object", NULL, dummy_notify_handler, NULL), return_val);
333  assert_non_null(sub);
334 
335  fsub = amxb_subscription_find(ctx, "object", dummy_notify_handler, NULL);
336  assert_non_null(fsub);
337  assert_ptr_equal(fsub, sub);
338 
339  assert_int_equal(amxb_subscription_delete(&sub), return_val);
340  assert_null(sub);
341 
342  assert_int_equal(amxb_subscription_new(&sub, ctx, "object", NULL, dummy_notify_handler, NULL), return_val);
343  assert_non_null(sub);
344 
345  assert_int_equal(amxb_disconnect(ctx), return_val);
346  amxb_free(&ctx);
347 
348  assert_int_equal(amxb_subscription_delete(&sub), return_val);
349  assert_null(sub);
350 
351  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
352  assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
353 }
amxb_subscription_find
amxb_subscription_t * amxb_subscription_find(amxb_bus_ctx_t *bus_ctx, const char *object, amxp_slot_fn_t slot_cb, void *priv)
Find an exact subscription.
Definition: amxb_subscription.c:216

◆ test_amxb_unsubscribe()

void test_amxb_unsubscribe ( UNUSED void **  state)

Definition at line 278 of file test_amxb_ba_subscribe.c.

278  {
279  amxb_bus_ctx_t* ctx = NULL;
280 
281  assert_int_equal(amxb_be_register(&dummy_be1), 0);
282  assert_int_equal(amxb_be_register(&dummy_be3), 0);
283  assert_int_equal(amxb_be_register(&dummy_be4), 0);
284 
285  return_val = 0;
286  sub_obj = "object";
287  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
288  assert_int_not_equal(amxb_unsubscribe(ctx, "object", NULL, NULL), return_val);
289  assert_int_not_equal(amxb_unsubscribe(ctx, NULL, NULL, NULL), return_val);
290  assert_int_not_equal(amxb_unsubscribe(NULL, NULL, NULL, NULL), return_val);
291  assert_int_equal(amxb_subscribe(ctx, "object", NULL, dummy_notify_handler, NULL), return_val);
292  assert_int_equal(amxb_subscribe(ctx, "object", NULL, dummy_notify_handler, NULL), return_val);
293  assert_int_equal(amxb_subscribe(ctx, "object", NULL, dummy_notify_handler2, NULL), return_val);
294  assert_int_equal(amxb_unsubscribe(ctx, "object", dummy_notify_handler2, NULL), return_val);
295  assert_int_equal(amxb_unsubscribe(ctx, "object", dummy_notify_handler, NULL), return_val);
296  return_val = -1;
297  sub_obj = "other_object";
298  assert_int_equal(amxb_subscribe(ctx, "other_object", NULL, dummy_notify_handler, NULL), return_val);
299  return_val = 0;
300  assert_int_not_equal(amxb_unsubscribe(ctx, "other_object", dummy_notify_handler, NULL), return_val);
301  assert_int_equal(amxb_subscribe(ctx, "other_object", NULL, dummy_notify_handler, NULL), return_val);
302  assert_int_equal(amxb_disconnect(ctx), return_val);
303  assert_int_not_equal(amxb_unsubscribe(ctx, "other_object", dummy_notify_handler, NULL), return_val);
304  amxb_free(&ctx);
305 
306  return_val = 0;
307  assert_int_not_equal(amxb_unsubscribe(ctx, "other_object", dummy_notify_handler, NULL), return_val);
308 
309  sub_obj = "test_object";
310  assert_int_equal(amxb_connect(&ctx, "ybus://test:80/var/run/ybus.sock"), 0);
311  assert_int_equal(amxb_subscribe(ctx, "test_object", NULL, dummy_notify_handler, NULL), return_val);
312  assert_int_equal(amxb_unsubscribe(ctx, "test_object", dummy_notify_handler, NULL), return_val);
313  amxb_free(&ctx);
314 
315  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
316  assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
317  assert_int_equal(amxb_be_unregister(&dummy_be4), 0);
318 }
dummy_be4
static amxb_be_funcs_t dummy_be4
Definition: test_amxb_ba_subscribe.c:180
dummy_notify_handler2
static void dummy_notify_handler2(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_amxb_ba_subscribe.c:198

◆ test_amxb_wait_for()

void test_amxb_wait_for ( UNUSED void **  state)

Definition at line 362 of file test_amxb_ba_subscribe.c.

362  {
363  amxb_bus_ctx_t* ctx = NULL;
364  uint32_t counter = 0;
365 
366  amxp_sigmngr_add_signal(NULL, "wait:done");
367  amxp_slot_connect(NULL, "wait:done", NULL, test_wait_done, &counter);
368 
369  assert_int_equal(amxb_be_register(&dummy_be1), 0);
370  assert_int_equal(amxb_be_register(&dummy_be3), 0);
371 
372  assert_int_equal(amxb_connect(&ctx, "xbus://test:80/var/run/xbus.sock"), 0);
373  assert_int_equal(amxb_wait_for_object("MyObject"), 0);
374  handle_events();
375  assert_int_equal(counter, 1);
376 
377  assert_int_equal(amxb_wait_for_object("MyObject."), 0);
378  assert_int_equal(amxb_wait_for_object("YetAnotherObject."), 0);
379  assert_int_equal(amxb_wait_for_object("YetAnotherObject.SubObject."), 0);
380  handle_events();
381  assert_int_equal(counter, 2);
382 
383  amxb_free(&ctx);
384 
385  assert_int_equal(amxb_connect(&ctx, "zbus://test:80/var/run/zbus.sock"), 0);
386  assert_int_equal(amxb_wait_for_object("MyObject."), 0);
387  assert_int_equal(amxb_wait_for_object("YetAnotherObject."), 0);
388  assert_int_equal(amxb_wait_for_object("YetAnotherObject.SubObject."), 0);
389  handle_events();
390  assert_int_equal(counter, 2);
391 
392  assert_int_equal(amxb_be_unregister(&dummy_be1), 0);
393  assert_int_equal(amxb_be_unregister(&dummy_be3), 0);
394 }
amxb_wait_for_object
int amxb_wait_for_object(const char *object)
Checks if an object is available, if not waits for it.
Definition: amxb_ba_wait_for.c:105
test_wait_done
static void test_wait_done(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, void *const priv)
Definition: test_amxb_ba_subscribe.c:355
handle_events
static void handle_events(void)
Definition: test_amxb_ba_subscribe.c:88

◆ test_wait_done()

static void test_wait_done ( UNUSED const char *const  sig_name,
UNUSED const amxc_var_t *const  data,
void *const  priv 
)
static

Definition at line 355 of file test_amxb_ba_subscribe.c.

357  {
358  uint32_t* counter = (uint32_t*) priv;
359  (*counter)++;
360 }

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,
.subscribe = dummy_subscribe,
.unsubscribe = dummy_unsubscribe,
.describe = dummy_describe,
.free = dummy_free,
.name = "xbus",
.size = sizeof(amxb_be_funcs_t),
}
amxb_be_funcs_t
struct _amxb_be_funcs amxb_be_funcs_t
Definition: amxb_types.h:79
dummy_describe
static int dummy_describe(void *const ctx, const char *object, UNUSED const char *search_path, UNUSED uint32_t flags, UNUSED uint32_t access, amxc_var_t *values, UNUSED int timeout)
Definition: test_amxb_ba_subscribe.c:126
dummy_unsubscribe
static int dummy_unsubscribe(void *const ctx, UNUSED const char *object)
Definition: test_amxb_ba_subscribe.c:155
dummy_connect
static void * dummy_connect(const char *host, const char *port, const char *path, UNUSED amxp_signal_mngr_t *sigmngr)
Definition: test_amxb_ba_subscribe.c:96
dummy_subscribe
static int dummy_subscribe(void *const ctx, UNUSED const char *object)
Definition: test_amxb_ba_subscribe.c:149
dummy_get_fd
static int dummy_get_fd(void *ctx)
Definition: test_amxb_ba_subscribe.c:112
dummy_disconnect
static int dummy_disconnect(void *ctx)
Definition: test_amxb_ba_subscribe.c:107
dummy_free
static void dummy_free(void *ctx)
Definition: test_amxb_ba_subscribe.c:117
dummy_read
static int dummy_read(void *const ctx)
Definition: test_amxb_ba_subscribe.c:121

Definition at line 161 of file test_amxb_ba_subscribe.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 174 of file test_amxb_ba_subscribe.c.

◆ dummy_be4

amxb_be_funcs_t dummy_be4
static
Initial value:
= {
.connect = dummy_connect,
.subscribe = dummy_subscribe,
.describe = dummy_describe,
.name = "ybus",
.size = sizeof(amxb_be_funcs_t),
}

Definition at line 180 of file test_amxb_ba_subscribe.c.

◆ dummy_ctx

char* dummy_ctx = "xbus"
static

Definition at line 79 of file test_amxb_ba_subscribe.c.

◆ return_val

int return_val
static

Definition at line 83 of file test_amxb_ba_subscribe.c.

◆ sub_obj

const char* sub_obj = NULL
static

Definition at line 84 of file test_amxb_ba_subscribe.c.

◆ verify_host

char verify_host[64]
static

Definition at line 80 of file test_amxb_ba_subscribe.c.

◆ verify_path

char verify_path[64]
static

Definition at line 82 of file test_amxb_ba_subscribe.c.

◆ verify_port

char verify_port[64]
static

Definition at line 81 of file test_amxb_ba_subscribe.c.