libamxd  6.4.1
Data Model Manager
Functions | Variables
test_amxd_function_get_supported.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_get_supported.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

int test_function_get_supported_setup (UNUSED void **state)
 
int test_function_get_supported_teardown (UNUSED void **state)
 
void test_amxd_can_get_supported_singleton_object (UNUSED void **state)
 
void test_amxd_can_get_supported_template_object (UNUSED void **state)
 
void test_amxd_get_supported_instance_object_succeeds (UNUSED void **state)
 
void test_amxd_can_get_supported_template_object_parameters (UNUSED void **state)
 
void test_amxd_can_get_supported_template_object_parameters_public_access (UNUSED void **state)
 
void test_amxd_can_get_supported_template_object_parameters_first_level (UNUSED void **state)
 
void test_amxd_can_get_supported_template_object_events (UNUSED void **state)
 
void test_amxd_get_supported_can_use_rel_path (UNUSED void **state)
 
void test_amxd_get_supported_fails_with_invalid_rel_path (UNUSED void **state)
 
void test_amxd_get_supported_can_use_to_high_access (UNUSED void **state)
 

Variables

static amxd_dm_t dm
 

Function Documentation

◆ test_amxd_can_get_supported_singleton_object()

void test_amxd_can_get_supported_singleton_object ( UNUSED void **  state)

Definition at line 174 of file test_amxd_function_get_supported.c.

174  {
175  amxd_object_t* singleton = NULL;
176  amxc_var_t retval;
177  amxc_var_t args;
178 
179  amxc_var_init(&args);
180  amxc_var_init(&retval);
181 
182  singleton = amxd_dm_findf(&dm, "Main.Singleton");
183  assert_non_null(singleton);
184 
185  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
186  assert_int_equal(amxd_object_invoke_function(singleton, "_get_supported", &args, &retval), 0);
187 
188  assert_non_null(GET_ARG(&retval, "Main.Singleton."));
189  amxc_var_dump(&retval, STDOUT_FILENO);
190 
191  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
192  amxc_var_add_key(bool, &args, "parameters", true);
193  assert_int_equal(amxd_object_invoke_function(singleton, "_get_supported", &args, &retval), 0);
194  assert_non_null(GET_ARG(&retval, "Main.Singleton."));
195  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.0.value_change"));
196  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.0.value_change"), 1);
197  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.0.access"));
198  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.0.access"), 1);
199  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.0.type"));
200  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.0.type"), 1);
201  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.1.value_change"));
202  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.1.value_change"), 2);
203  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.1.access"));
204  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.1.access"), 0);
205  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.1.type"));
206  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.1.type"), 8);
207  amxc_var_dump(&retval, STDOUT_FILENO);
208 
209  amxc_var_clean(&retval);
210  amxc_var_clean(&args);
211 }
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_get_supported.c:78

◆ test_amxd_can_get_supported_template_object()

void test_amxd_can_get_supported_template_object ( UNUSED void **  state)

Definition at line 213 of file test_amxd_function_get_supported.c.

213  {
214  amxd_object_t* templ = NULL;
215  amxc_var_t retval;
216  amxc_var_t args;
217 
218  amxc_var_init(&args);
219  amxc_var_init(&retval);
220 
221  templ = amxd_dm_findf(&dm, "Main.Template");
222  assert_non_null(templ);
223 
224  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
225  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
226 
227  amxc_var_dump(&retval, STDOUT_FILENO);
228  assert_non_null(GET_ARG(&retval, "Main.Template.{i}."));
229  assert_true(GETP_BOOL(&retval, "'Main.Template.{i}.'.is_multi_instance"));
230  assert_int_equal(GETP_INT32(&retval, "'Main.Template.{i}.'.supported_params.2.access"), 0);
231  assert_non_null(GET_ARG(&retval, "Main.Template.{i}.SubObject."));
232  assert_false(GETP_BOOL(&retval, "'Main.Template.{i}.SubObject'.is_multi_instance"));
233 
234  amxc_var_clean(&retval);
235  amxc_var_clean(&args);
236 }

◆ test_amxd_can_get_supported_template_object_events()

void test_amxd_can_get_supported_template_object_events ( UNUSED void **  state)

Definition at line 367 of file test_amxd_function_get_supported.c.

367  {
368  amxd_object_t* templ = NULL;
369  amxc_var_t retval;
370  amxc_var_t args;
371 
372  amxc_var_init(&args);
373  amxc_var_init(&retval);
374 
375  templ = amxd_dm_findf(&dm, "Main.Template");
376  assert_non_null(templ);
377 
378  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
379  amxc_var_add_key(bool, &args, "first_level_only", false);
380  amxc_var_add_key(bool, &args, "events", true);
381  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
382 
383  amxc_var_dump(&retval, STDOUT_FILENO);
384  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_events.'MyEvent!'"));
385 
386  amxc_var_clean(&retval);
387  amxc_var_clean(&args);
388 }

◆ test_amxd_can_get_supported_template_object_parameters()

void test_amxd_can_get_supported_template_object_parameters ( UNUSED void **  state)

Definition at line 263 of file test_amxd_function_get_supported.c.

263  {
264  amxd_object_t* templ = NULL;
265  amxc_var_t retval;
266  amxc_var_t args;
267 
268  amxc_var_init(&args);
269  amxc_var_init(&retval);
270 
271  templ = amxd_dm_findf(&dm, "Main.Template");
272  assert_non_null(templ);
273 
274  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
275  amxc_var_add_key(bool, &args, "first_level_only", false);
276  amxc_var_add_key(bool, &args, "parameters", true);
277  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
278 
279  amxc_var_dump(&retval, STDOUT_FILENO);
280  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"));
281  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"), "param1");
282  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.type"));
283  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
284  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"));
285  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"), "param2");
286  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.type"));
287  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.1.type"), AMXC_VAR_ID_UINT32);
288  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"));
289  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"), "param1");
290  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"));
291  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
292  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.ProtectedSubObject.'.supported_params.0.type"));
293  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.ProtectedSubObject.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
294 
295  amxc_var_clean(&retval);
296  amxc_var_clean(&args);
297 }

◆ test_amxd_can_get_supported_template_object_parameters_first_level()

void test_amxd_can_get_supported_template_object_parameters_first_level ( UNUSED void **  state)

Definition at line 335 of file test_amxd_function_get_supported.c.

335  {
336  amxd_object_t* templ = NULL;
337  amxc_var_t retval;
338  amxc_var_t args;
339 
340  amxc_var_init(&args);
341  amxc_var_init(&retval);
342 
343  templ = amxd_dm_findf(&dm, "Main.Template");
344  assert_non_null(templ);
345 
346  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
347  amxc_var_add_key(bool, &args, "first_level_only", true);
348  amxc_var_add_key(bool, &args, "parameters", true);
349  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
350 
351  amxc_var_dump(&retval, STDOUT_FILENO);
352  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"));
353  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"), "param1");
354  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.type"));
355  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
356  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"));
357  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"), "param2");
358  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.type"));
359  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.1.type"), AMXC_VAR_ID_UINT32);
360  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'"));
361  assert_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params"));
362 
363  amxc_var_clean(&retval);
364  amxc_var_clean(&args);
365 }

◆ test_amxd_can_get_supported_template_object_parameters_public_access()

void test_amxd_can_get_supported_template_object_parameters_public_access ( UNUSED void **  state)

Definition at line 299 of file test_amxd_function_get_supported.c.

299  {
300  amxd_object_t* templ = NULL;
301  amxc_var_t retval;
302  amxc_var_t args;
303 
304  amxc_var_init(&args);
305  amxc_var_init(&retval);
306 
307  templ = amxd_dm_findf(&dm, "Main.Template");
308  assert_non_null(templ);
309 
310  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
311  amxc_var_add_key(bool, &args, "first_level_only", false);
312  amxc_var_add_key(bool, &args, "parameters", true);
313  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_public);
314  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
315 
316  amxc_var_dump(&retval, STDOUT_FILENO);
317  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"));
318  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"), "param1");
319  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.type"));
320  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
321  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"));
322  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"), "param2");
323  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.type"));
324  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.1.type"), AMXC_VAR_ID_UINT32);
325  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"));
326  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"), "param1");
327  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"));
328  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
329  assert_null(GETP_ARG(&retval, "'Main.Template.{i}.ProtectedSubObject.'.supported_params.0.type"));
330 
331  amxc_var_clean(&retval);
332  amxc_var_clean(&args);
333 }
amxd_dm_access_public
@ amxd_dm_access_public
Definition: amxd_types.h:136

◆ test_amxd_get_supported_can_use_rel_path()

void test_amxd_get_supported_can_use_rel_path ( UNUSED void **  state)

Definition at line 390 of file test_amxd_function_get_supported.c.

390  {
391  amxd_object_t* root = NULL;
392  amxc_var_t retval;
393  amxc_var_t args;
394 
395  amxc_var_init(&args);
396  amxc_var_init(&retval);
397 
398  root = amxd_dm_findf(&dm, "Main.");
399  assert_non_null(root);
400 
401  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
402  amxc_var_add_key(cstring_t, &args, "rel_path", "Singleton.");
403  assert_int_equal(amxd_object_invoke_function(root, "_get_supported", &args, &retval), 0);
404 
405  amxc_var_clean(&retval);
406  amxc_var_clean(&args);
407 }

◆ test_amxd_get_supported_can_use_to_high_access()

void test_amxd_get_supported_can_use_to_high_access ( UNUSED void **  state)

Definition at line 429 of file test_amxd_function_get_supported.c.

429  {
430  amxd_object_t* singleton = NULL;
431  amxc_var_t retval;
432  amxc_var_t args;
433 
434  amxc_var_init(&args);
435  amxc_var_init(&retval);
436 
437  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
438  assert_non_null(singleton);
439 
440  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
441  amxc_var_add_key(uint32_t, &args, "access", 100);
442  assert_int_equal(amxd_object_invoke_function(singleton, "_get_supported", &args, &retval), 0);
443  amxc_var_dump(&retval, STDOUT_FILENO);
444 
445  amxc_var_clean(&retval);
446  amxc_var_clean(&args);
447 }

◆ test_amxd_get_supported_fails_with_invalid_rel_path()

void test_amxd_get_supported_fails_with_invalid_rel_path ( UNUSED void **  state)

Definition at line 409 of file test_amxd_function_get_supported.c.

409  {
410  amxd_object_t* root = NULL;
411  amxc_var_t retval;
412  amxc_var_t args;
413 
414  amxc_var_init(&args);
415  amxc_var_init(&retval);
416 
417  root = amxd_dm_findf(&dm, "Main.");
418  assert_non_null(root);
419 
420  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
421  amxc_var_add_key(cstring_t, &args, "rel_path", "NotExisting.Object.");
422  assert_int_not_equal(amxd_object_invoke_function(root, "_get_supported", &args, &retval), 0);
423 
424  amxc_var_clean(&retval);
425  amxc_var_clean(&args);
426 }

◆ test_amxd_get_supported_instance_object_succeeds()

void test_amxd_get_supported_instance_object_succeeds ( UNUSED void **  state)

Definition at line 238 of file test_amxd_function_get_supported.c.

238  {
239  amxd_object_t* inst = NULL;
240  amxc_var_t retval;
241  amxc_var_t args;
242 
243  amxc_var_init(&args);
244  amxc_var_init(&retval);
245 
246  inst = amxd_dm_findf(&dm, "Main.Template.1.");
247  assert_non_null(inst);
248 
249  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
250  assert_int_equal(amxd_object_invoke_function(inst, "_get_supported", &args, &retval), 0);
251  amxc_var_dump(&retval, STDOUT_FILENO);
252 
253  inst = amxd_dm_findf(&dm, "Main.Template.1.SubObject");
254  assert_non_null(inst);
255 
256  assert_int_equal(amxd_object_invoke_function(inst, "_get_supported", &args, &retval), 0);
257  amxc_var_dump(&retval, STDOUT_FILENO);
258 
259  amxc_var_clean(&retval);
260  amxc_var_clean(&args);
261 }

◆ test_function_get_supported_setup()

int test_function_get_supported_setup ( UNUSED void **  state)

Definition at line 80 of file test_amxd_function_get_supported.c.

80  {
81  amxd_object_t* root = NULL;
82  amxd_object_t* singleton = NULL;
83  amxd_object_t* template = NULL;
84  amxd_object_t* instance = NULL;
85  amxd_param_t* param = NULL;
86  amxd_function_t* func = NULL;
87  amxc_var_t def_val;
88 
89  assert_int_equal(amxd_dm_init(&dm), 0);
90  amxc_var_init(&def_val);
91 
92  // object Main
93  assert_int_equal(amxd_object_new(&root, amxd_object_singleton, "Main"), 0);
94  assert_int_equal(amxd_dm_add_root_object(&dm, root), 0);
95 
96  // %read-only object Main.Template[]
97  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
98  amxd_object_set_attr(template, amxd_oattr_read_only, true);
99  assert_int_equal(amxd_object_add_object(root, template), 0);
100  // string param1
101  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
102  assert_int_equal(amxd_object_add_param(template, param), 0);
103  // %read-only uint32 param2
104  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
105  amxd_param_set_attr(param, amxd_pattr_read_only, true);
106  assert_int_equal(amxd_object_add_param(template, param), 0);
107  // %key string param3
108  assert_int_equal(amxd_param_new(&param, "param3", AMXC_VAR_ID_CSTRING), 0);
109  amxd_param_set_attr(param, amxd_pattr_key, true);
110  assert_int_equal(amxd_object_add_param(template, param), 0);
111  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
112  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
113  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
114  amxc_var_set(uint32_t, &def_val, 10);
115  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
116  assert_int_equal(amxd_object_add_function(template, func), 0);
117 
118  assert_int_equal(amxd_object_add_event(template, "MyEvent!"), 0);
119 
120  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "SubObject"), 0);
121  amxd_object_set_attr(singleton, amxd_oattr_persistent, true);
122  assert_int_equal(amxd_object_add_object(template, singleton), 0);
123  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
124  assert_int_equal(amxd_object_add_param(singleton, param), 0);
125 
126  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "PrivateSubObject"), 0);
127  amxd_object_set_attr(singleton, amxd_oattr_private, true);
128  assert_int_equal(amxd_object_add_object(template, singleton), 0);
129  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
130  assert_int_equal(amxd_object_add_param(singleton, param), 0);
131 
132  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "ProtectedSubObject"), 0);
133  amxd_object_set_attr(singleton, amxd_oattr_protected, true);
134  assert_int_equal(amxd_object_add_object(template, singleton), 0);
135  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
136  assert_int_equal(amxd_object_add_param(singleton, param), 0);
137 
138  // %persistent object Main.Singleton
139  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "Singleton"), 0);
140  amxd_object_set_attr(singleton, amxd_oattr_persistent, true);
141  assert_int_equal(amxd_object_add_object(root, singleton), 0);
142  // string param1
143  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
144  assert_int_equal(amxd_object_add_param(singleton, param), 0);
145  // %read-only uint32 param2
146  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
147  amxd_param_set_attr(param, amxd_pattr_read_only, true);
148  amxd_param_set_attr(param, amxd_pattr_variable, true);
149  assert_int_equal(amxd_object_add_param(singleton, param), 0);
150  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
151  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
152  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
153  amxc_var_set(uint32_t, &def_val, 10);
154  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
155  assert_int_equal(amxd_object_add_function(singleton, func), 0);
156 
157  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
158  amxc_var_add_key(cstring_t, &def_val, "param3", "Key1");
159  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance1", 0, &def_val), 0);
160  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
161  amxc_var_add_key(cstring_t, &def_val, "param3", "Key2");
162  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance2", 0, &def_val), 0);
163 
164  amxc_var_clean(&def_val);
165  return 0;
166 }
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_variable
@ amxd_pattr_variable
Definition: amxd_types.h:360
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_read_only
@ amxd_oattr_read_only
Definition: amxd_types.h:199
amxd_oattr_protected
@ amxd_oattr_protected
Definition: amxd_types.h:210
amxd_oattr_persistent
@ amxd_oattr_persistent
Definition: amxd_types.h:200
amxd_oattr_private
@ amxd_oattr_private
Definition: amxd_types.h:202
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_add_event
amxd_status_t amxd_object_add_event(amxd_object_t *const object, const char *event_name)
Adds an event definition to the object.
Definition: amxd_object_event.c:411
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_get_supported_teardown()

int test_function_get_supported_teardown ( UNUSED void **  state)

Definition at line 168 of file test_amxd_function_get_supported.c.

168  {
169  amxd_dm_clean(&dm);
170 
171  return 0;
172 }
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_get_supported.c.