libamxd  6.4.1
Data Model Manager
Functions | Variables
test_amxd_function_set.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <cmocka.h>
#include <amxc/amxc.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.h>
#include <amxp/amxp_timer.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_event.h>
#include <amxd/amxd_transaction.h>
#include "test_amxd_function_set.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

int test_function_set_setup (UNUSED void **state)
 
int test_function_set_teardown (UNUSED void **state)
 
void test_amxd_can_set_instance_object (UNUSED void **state)
 
void test_amxd_set_fails_if_unique_value_exists (UNUSED void **state)
 
void test_amxd_set_can_use_rel_path (UNUSED void **state)
 
void test_amxd_set_fails_with_invalid_rel_path (UNUSED void **state)
 
void test_amxd_set_can_use_to_high_access (UNUSED void **state)
 
void test_amxd_set_partial (UNUSED void **state)
 
void test_amxd_set_fails_if_not_partial (UNUSED void **state)
 
void test_amxd_set_optional (UNUSED void **state)
 

Variables

static amxd_dm_t dm
 

Function Documentation

◆ test_amxd_can_set_instance_object()

void test_amxd_can_set_instance_object ( UNUSED void **  state)

Definition at line 183 of file test_amxd_function_set.c.

183  {
184  amxd_object_t* template = NULL;
185  amxc_var_t retval;
186  amxc_var_t args;
187  amxc_var_t* params = NULL;
188 
189  amxc_var_init(&args);
190  amxc_var_init(&retval);
191 
192  template = amxd_dm_findf(&dm, "Main.Template.1");
193  assert_non_null(template);
194 
195  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
196  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
197  amxc_var_add_key(cstring_t, params, "param1", "TEST");
198  assert_int_equal(amxd_object_invoke_function(template, "_set", &args, &retval), 0);
199 
200  amxc_var_dump(&retval, STDOUT_FILENO);
201  assert_non_null(GETP_ARG(&retval, "'Main.Template.1.'"));
202 
203  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
204 
205  amxc_var_clean(&retval);
206  amxc_var_clean(&args);
207 }
amxd_dm_findf
amxd_object_t * amxd_dm_findf(amxd_dm_t *const dm, const char *abs_path,...) __attribute__((format(printf
amxd_object_invoke_function
amxd_status_t amxd_object_invoke_function(amxd_object_t *const object, const char *func_name, amxc_var_t *const args, amxc_var_t *const ret)
Calls an object RPC method.
Definition: amxd_object_function.c:245
_amxd_object
Definition: amxd_types.h:229
dm
static amxd_dm_t dm
Definition: test_amxd_function_set.c:78

◆ test_amxd_set_can_use_rel_path()

void test_amxd_set_can_use_rel_path ( UNUSED void **  state)

Definition at line 235 of file test_amxd_function_set.c.

235  {
236  amxd_object_t* root = NULL;
237  amxc_var_t retval;
238  amxc_var_t args;
239  amxc_var_t* params = NULL;
240 
241  amxc_var_init(&args);
242  amxc_var_init(&retval);
243 
244  root = amxd_dm_findf(&dm, "Main.");
245  assert_non_null(root);
246 
247  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
248  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
249  amxc_var_add_key(cstring_t, params, "param1", "TEST");
250  amxc_var_add_key(cstring_t, &args, "rel_path", "Template.*.");
251  assert_int_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
252 
253  amxc_var_dump(&retval, STDOUT_FILENO);
254  assert_non_null(GETP_ARG(&retval, "'Main.Template.1.'"));
255  assert_non_null(GETP_ARG(&retval, "'Main.Template.2.'"));
256  assert_non_null(GETP_ARG(&retval, "'Main.Template.3.'"));
257  assert_non_null(GETP_ARG(&retval, "'Main.Template.4.'"));
258  assert_non_null(GETP_ARG(&retval, "'Main.Template.5.'"));
259  assert_non_null(GETP_ARG(&retval, "'Main.Template.6.'"));
260  assert_non_null(GETP_ARG(&retval, "'Main.Template.7.'"));
261 
262  root = amxd_dm_findf(&dm, "Main.Template.");
263  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
264  amxc_var_add_key(cstring_t, params, "param1", "TEST");
265  amxc_var_add_key(cstring_t, &args, "rel_path", "[Alias == 'YAI1' || Alias == 'YAI2'].");
266  assert_int_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
267 
268  amxc_var_dump(&retval, STDOUT_FILENO);
269  assert_non_null(GETP_ARG(&retval, "'Main.Template.5.'"));
270  assert_non_null(GETP_ARG(&retval, "'Main.Template.6.'"));
271 
272  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
273  amxc_var_add_key(cstring_t, params, "param1", "TEST");
274  amxc_var_add_key(cstring_t, &args, "rel_path", "[Alias == 'FOO' || Alias == 'BAR'].");
275  assert_int_not_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
276  amxc_var_dump(&retval, STDOUT_FILENO);
277 
278  amxc_var_clean(&retval);
279 
280  root = amxd_dm_findf(&dm, "Main.");
281  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
282  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
283  amxc_var_add_key(cstring_t, params, "param1", "TEST2");
284  amxc_var_add_key(cstring_t, &args, "rel_path", "Template.YAI1.");
285  assert_int_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
286  amxc_var_dump(&retval, STDOUT_FILENO);
287  assert_non_null(GETP_ARG(&retval, "'Main.Template.5.'"));
288 
289  amxc_var_clean(&retval);
290  amxc_var_clean(&args);
291 }

◆ test_amxd_set_can_use_to_high_access()

void test_amxd_set_can_use_to_high_access ( UNUSED void **  state)

Definition at line 316 of file test_amxd_function_set.c.

316  {
317  amxd_object_t* obj = NULL;
318  amxc_var_t retval;
319  amxc_var_t args;
320  amxc_var_t* params = NULL;
321 
322  amxc_var_init(&args);
323  amxc_var_init(&retval);
324 
325  obj = amxd_dm_findf(&dm, "Main.Template.1.");
326  assert_non_null(obj);
327 
328  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
329  amxc_var_add_key(uint32_t, &args, "access", 100);
330  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
331  amxc_var_add_key(cstring_t, params, "param1", "TEST");
332  assert_int_equal(amxd_object_invoke_function(obj, "_set", &args, &retval), 0);
333 
334  amxc_var_clean(&retval);
335  amxc_var_clean(&args);
336 }

◆ test_amxd_set_fails_if_not_partial()

void test_amxd_set_fails_if_not_partial ( UNUSED void **  state)

Definition at line 372 of file test_amxd_function_set.c.

372  {
373  amxd_object_t* singleton = NULL;
374  amxc_var_t retval;
375  amxc_var_t args;
376  amxc_var_t* params = NULL;
377  amxc_var_t verify;
378 
379  amxc_var_init(&args);
380  amxc_var_init(&retval);
381  amxc_var_init(&verify);
382 
383  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
384  assert_non_null(singleton);
385 
386  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
387  amxc_var_add_key(uint32_t, &args, "access", 100);
388  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
389  amxc_var_add_key(cstring_t, params, "param1", "TEST");
390  amxc_var_add_key(uint32_t, params, "param2", 1024);
391  assert_int_not_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
392  amxc_var_dump(&retval, STDOUT_FILENO);
393 
394  assert_int_equal(amxd_object_get_params(singleton, &verify, amxd_dm_access_protected), 0);
395  assert_int_equal(GET_UINT32(&verify, "param2"), 0);
396  assert_string_equal(GET_CHAR(&verify, "param1"), "");
397 
398  amxc_var_clean(&retval);
399  amxc_var_clean(&args);
400  amxc_var_clean(&verify);
401 }
amxd_dm_access_protected
@ amxd_dm_access_protected
Definition: amxd_types.h:139
amxd_object_get_params
amxd_status_t amxd_object_get_params(amxd_object_t *const object, amxc_var_t *const params, amxd_dm_access_t access)
Gets all parameter values of an object.
Definition: amxd_action_object_read.c:314

◆ test_amxd_set_fails_if_unique_value_exists()

void test_amxd_set_fails_if_unique_value_exists ( UNUSED void **  state)

Definition at line 209 of file test_amxd_function_set.c.

209  {
210  amxd_object_t* template = NULL;
211  amxc_var_t retval;
212  amxc_var_t args;
213  amxc_var_t* params = NULL;
214 
215  amxc_var_init(&args);
216  amxc_var_init(&retval);
217 
218  template = amxd_dm_findf(&dm, "Main.Template.1");
219  assert_non_null(template);
220 
221  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
222  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
223  amxc_var_add_key(uint32_t, params, "param3", 2);
224  assert_int_not_equal(amxd_object_invoke_function(template, "_set", &args, &retval), 0);
225 
226  amxc_var_dump(&retval, STDOUT_FILENO);
227  assert_non_null(GETP_ARG(&retval, "'Main.Template.1.'"));
228 
229  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
230 
231  amxc_var_clean(&retval);
232  amxc_var_clean(&args);
233 }

◆ test_amxd_set_fails_with_invalid_rel_path()

void test_amxd_set_fails_with_invalid_rel_path ( UNUSED void **  state)

Definition at line 293 of file test_amxd_function_set.c.

293  {
294  amxd_object_t* root = NULL;
295  amxc_var_t retval;
296  amxc_var_t args;
297  amxc_var_t* params = NULL;
298 
299  amxc_var_init(&args);
300  amxc_var_init(&retval);
301 
302  root = amxd_dm_findf(&dm, "Main.");
303  assert_non_null(root);
304 
305  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
306  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
307  amxc_var_add_key(cstring_t, params, "param1", "TEST");
308  amxc_var_add_key(cstring_t, &args, "rel_path", "NotExisting.Object.");
309  assert_int_not_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
310 
311  amxc_var_clean(&retval);
312  amxc_var_clean(&args);
313 }

◆ test_amxd_set_optional()

void test_amxd_set_optional ( UNUSED void **  state)

Definition at line 404 of file test_amxd_function_set.c.

404  {
405  amxd_object_t* singleton = NULL;
406  amxc_var_t retval;
407  amxc_var_t args;
408  amxc_var_t* params = NULL;
409  amxc_var_t verify;
410 
411  amxc_var_init(&args);
412  amxc_var_init(&retval);
413  amxc_var_init(&verify);
414 
415  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
416  assert_non_null(singleton);
417 
418  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
419  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_protected);
420  params = amxc_var_add_key(amxc_htable_t, &args, "oparameters", NULL);
421  amxc_var_add_key(cstring_t, params, "param1", "TEST");
422  amxc_var_add_key(uint32_t, params, "param2", 1024);
423  amxc_var_add_key(cstring_t, params, "param3", "not valid value");
424  assert_int_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
425  amxc_var_dump(&retval, STDOUT_FILENO);
426  assert_int_equal(amxc_var_type_of(GETP_ARG(&retval, "'Main.Singleton.'.param2")), AMXC_VAR_ID_HTABLE);
427  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.param2.error_code"), 15);
428  assert_false(GETP_BOOL(&retval, "'Main.Singleton.'.param2.required"));
429 
430  assert_int_equal(amxd_object_get_params(singleton, &verify, amxd_dm_access_protected), 0);
431  amxc_var_dump(&verify, STDOUT_FILENO);
432  assert_int_equal(GET_UINT32(&verify, "param2"), 0);
433  assert_string_equal(GET_CHAR(&verify, "param1"), "TEST");
434 
435  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
436  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_protected);
437  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
438  amxc_var_add_key(cstring_t, params, "param3", "not valid value");
439  params = amxc_var_add_key(amxc_htable_t, &args, "oparameters", NULL);
440  amxc_var_add_key(cstring_t, params, "param1", "TEST");
441  amxc_var_add_key(uint32_t, params, "param2", 1024);
442  assert_int_not_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
443  amxc_var_dump(&retval, STDOUT_FILENO);
444 
445  amxc_var_clean(&retval);
446  amxc_var_clean(&args);
447  amxc_var_clean(&verify);
448 }

◆ test_amxd_set_partial()

void test_amxd_set_partial ( UNUSED void **  state)

Definition at line 338 of file test_amxd_function_set.c.

338  {
339  amxd_object_t* singleton = NULL;
340  amxc_var_t retval;
341  amxc_var_t args;
342  amxc_var_t* params = NULL;
343  amxc_var_t verify;
344 
345  amxc_var_init(&args);
346  amxc_var_init(&retval);
347  amxc_var_init(&verify);
348 
349  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
350  assert_non_null(singleton);
351 
352  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
353  amxc_var_add_key(uint32_t, &args, "access", 100);
354  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
355  amxc_var_add_key(cstring_t, params, "param1", "TEST");
356  amxc_var_add_key(uint32_t, params, "param2", 1024);
357  assert_int_not_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
358  amxc_var_dump(&retval, STDOUT_FILENO);
359  assert_int_equal(amxc_var_type_of(GETP_ARG(&retval, "'Main.Singleton.'.param2")), AMXC_VAR_ID_HTABLE);
360  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.param2.error_code"), 15);
361  assert_true(GETP_BOOL(&retval, "'Main.Singleton.'.param2.required"));
362 
363  assert_int_equal(amxd_object_get_params(singleton, &verify, amxd_dm_access_protected), 0);
364  assert_int_equal(GET_UINT32(&verify, "param2"), 0);
365  assert_string_equal(GET_CHAR(&verify, "param1"), "");
366 
367  amxc_var_clean(&retval);
368  amxc_var_clean(&args);
369  amxc_var_clean(&verify);
370 }

◆ test_function_set_setup()

int test_function_set_setup ( UNUSED void **  state)

Definition at line 80 of file test_amxd_function_set.c.

80  {
81  amxd_object_t* root = NULL;
82  amxd_object_t* singleton = NULL;
83  amxd_object_t* template = NULL;
84  amxd_object_t* sub = NULL;
85  amxd_object_t* instance = NULL;
86  amxd_param_t* param = NULL;
87  amxd_function_t* func = NULL;
88  amxc_var_t def_val;
89  amxc_var_t* param3_val = NULL;
90 
91  assert_int_equal(amxd_dm_init(&dm), 0);
92  amxc_var_init(&def_val);
93 
94  // object Main
95  assert_int_equal(amxd_object_new(&root, amxd_object_singleton, "Main"), 0);
96  assert_int_equal(amxd_dm_add_root_object(&dm, root), 0);
97 
98  // %persistent object Main.Template[]
99  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
100  amxd_object_set_attr(template, amxd_oattr_persistent, true);
101  assert_int_equal(amxd_object_add_object(root, template), 0);
102  // %unique %key string Alias
103  assert_int_equal(amxd_param_new(&param, "Alias", AMXC_VAR_ID_CSTRING), 0);
104  amxd_param_set_attr(param, amxd_pattr_key, true);
105  amxd_param_set_attr(param, amxd_pattr_unique, true);
106  assert_int_equal(amxd_object_add_param(template, param), 0);
107  // string param1
108  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
109  assert_int_equal(amxd_object_add_param(template, param), 0);
110  // %read-only uint32 param2
111  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
112  amxd_param_set_attr(param, amxd_pattr_read_only, true);
113  assert_int_equal(amxd_object_add_param(template, param), 0);
114  // %unique uint32 param3
115  assert_int_equal(amxd_param_new(&param, "param3", AMXC_VAR_ID_UINT32), 0);
116  amxd_param_set_attr(param, amxd_pattr_unique, true);
117  assert_int_equal(amxd_object_add_param(template, param), 0);
118  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
119  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
120  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
121  amxc_var_set(uint32_t, &def_val, 10);
122  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
123  assert_int_equal(amxd_object_add_function(template, func), 0);
124 
125  // object Main.Template[].Sub[]
126  assert_int_equal(amxd_object_new(&sub, amxd_object_template, "Sub"), 0);
127  assert_int_equal(amxd_object_add_object(template, sub), 0);
128  // %unique %key string Alias
129  assert_int_equal(amxd_param_new(&param, "Alias", AMXC_VAR_ID_CSTRING), 0);
130  amxd_param_set_attr(param, amxd_pattr_key, true);
131  amxd_param_set_attr(param, amxd_pattr_unique, true);
132  assert_int_equal(amxd_object_add_param(sub, param), 0);
133 
134  // %persistent object Main.Singleton
135  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "Singleton"), 0);
136  amxd_object_set_attr(singleton, amxd_oattr_persistent, true);
137  assert_int_equal(amxd_object_add_object(root, singleton), 0);
138  // string param1
139  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
140  assert_int_equal(amxd_object_add_param(singleton, param), 0);
141  // %read-only uint32 param2
142  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
143  amxd_param_set_attr(param, amxd_pattr_read_only, true);
144  assert_int_equal(amxd_object_add_param(singleton, param), 0);
145  // bool param3
146  assert_int_equal(amxd_param_new(&param, "param3", AMXC_VAR_ID_BOOL), 0);
147  assert_int_equal(amxd_object_add_param(singleton, param), 0);
148  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
149  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
150  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
151  amxc_var_set(uint32_t, &def_val, 10);
152  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
153  assert_int_equal(amxd_object_add_function(singleton, func), 0);
154 
155  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
156  param3_val = amxc_var_add_key(uint32_t, &def_val, "param3", 1);
157  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance1", 0, &def_val), 0);
158  amxc_var_set(uint32_t, param3_val, 2);
159  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance2", 0, &def_val), 0);
160  amxc_var_set(uint32_t, param3_val, 3);
161  assert_int_equal(amxd_object_add_instance(&instance, template, "Test1", 0, &def_val), 0);
162  amxc_var_set(uint32_t, param3_val, 4);
163  assert_int_equal(amxd_object_add_instance(&instance, template, "Test2", 0, &def_val), 0);
164  amxc_var_set(uint32_t, param3_val, 5);
165  assert_int_equal(amxd_object_add_instance(&instance, template, "YAI1", 0, &def_val), 0);
166  amxc_var_set(uint32_t, param3_val, 6);
167  assert_int_equal(amxd_object_add_instance(&instance, template, "YAI2", 0, &def_val), 0);
168  amxc_var_set(uint32_t, param3_val, 7);
169  assert_int_equal(amxd_object_add_instance(&instance, template, "YAI3", 0, &def_val), 0);
170  template = amxd_object_findf(instance, "Sub");
171  assert_int_equal(amxd_object_add_instance(&instance, template, "SUBINST", 0, NULL), 0);
172 
173  amxc_var_clean(&def_val);
174  return 0;
175 }
amxd_param_new
amxd_status_t amxd_param_new(amxd_param_t **param, const char *name, const uint32_t type)
Definition: amxd_parameter.c:239
amxd_param_set_attr
amxd_status_t amxd_param_set_attr(amxd_param_t *param, const amxd_pattr_id_t attr, const bool enable)
Definition: amxd_parameter.c:326
amxd_pattr_unique
@ amxd_pattr_unique
Definition: amxd_types.h:363
amxd_pattr_key
@ amxd_pattr_key
Definition: amxd_types.h:362
amxd_pattr_read_only
@ amxd_pattr_read_only
Definition: amxd_types.h:358
amxd_oattr_persistent
@ amxd_oattr_persistent
Definition: amxd_types.h:200
amxd_object_template
@ amxd_object_template
Definition: amxd_types.h:183
amxd_object_singleton
@ amxd_object_singleton
Definition: amxd_types.h:181
amxd_dm_add_root_object
amxd_status_t amxd_dm_add_root_object(amxd_dm_t *const dm, amxd_object_t *const object)
Adds an object to the root of the data model.
Definition: amxd_dm.c:418
amxd_dm_init
amxd_status_t amxd_dm_init(amxd_dm_t *dm)
Initializes a data model structure.
Definition: amxd_dm.c:334
amxd_object_findf
amxd_object_t * amxd_object_findf(amxd_object_t *object, const char *rel_path,...) __attribute__((format(printf
Find an object in the data model tree, starting from an object.
amxd_object_add_object
amxd_status_t amxd_object_add_object(amxd_object_t *const parent, amxd_object_t *const child)
Adds an object in the data model tree.
Definition: amxd_object.c:207
amxd_object_add_param
amxd_status_t amxd_object_add_param(amxd_object_t *const object, amxd_param_t *const param)
Adds a parameter definition to an object.
Definition: amxd_object_parameter.c:96
amxd_object_add_function
amxd_status_t amxd_object_add_function(amxd_object_t *const object, amxd_function_t *const func)
Adds an RPC method definition to the object definition.
Definition: amxd_object_function.c:140
amxd_object_set_attr
amxd_status_t amxd_object_set_attr(amxd_object_t *const object, const amxd_oattr_id_t attr, const bool enable)
Sets or unsets an object attribute.
Definition: amxd_object.c:269
amxd_object_new
amxd_status_t amxd_object_new(amxd_object_t **object, const amxd_object_type_t type, const char *name)
Data model object constructor function.
Definition: amxd_object.c:185
amxd_object_add_instance
amxd_status_t amxd_object_add_instance(amxd_object_t **object, amxd_object_t *templ, const char *name, uint32_t index, amxc_var_t *values)
Data model object constructor function.
Definition: amxd_action_object_add_inst.c:301
amxd_function_new
amxd_status_t amxd_function_new(amxd_function_t **func, const char *name, const uint32_t ret_type, amxd_object_fn_t impl)
Data model RPC method constructor function.
Definition: amxd_function.c:146
amxd_function_new_arg
amxd_status_t amxd_function_new_arg(amxd_function_t *func, const char *name, const uint32_t type, amxc_var_t *default_value)
Adds an argument definition to a RPC method definition.
Definition: amxd_function_args.c:140
_amxd_function
RPC method structure.
Definition: amxd_types.h:341
_amxd_parameter
Definition: amxd_types.h:386

◆ test_function_set_teardown()

int test_function_set_teardown ( UNUSED void **  state)

Definition at line 177 of file test_amxd_function_set.c.

177  {
178  amxd_dm_clean(&dm);
179 
180  return 0;
181 }
amxd_dm_clean
void amxd_dm_clean(amxd_dm_t *dm)
Cleans a data model structure.
Definition: amxd_dm.c:365

Variable Documentation

◆ dm

amxd_dm_t dm
static

Definition at line 78 of file test_amxd_function_set.c.