libamxd  6.4.1
Data Model Manager
test_amxd_parameter_validation.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdarg.h>
57 #include <stddef.h>
58 #include <setjmp.h>
59 #include <fcntl.h>
60 #include <unistd.h>
61 #include <signal.h>
62 #include <cmocka.h>
63 
64 #include <amxc/amxc.h>
65 #include <amxp/amxp_signal.h>
66 #include <amxp/amxp_slot.h>
67 
68 #include <amxd/amxd_common.h>
69 #include <amxd/amxd_dm.h>
70 #include <amxd/amxd_object.h>
71 #include <amxd/amxd_parameter.h>
72 #include <amxd/amxd_function.h>
73 #include <amxd/amxd_action.h>
74 
75 #include "test_amxd_parameter_validation.h"
76 
77 #include <amxc/amxc_macros.h>
78 static amxd_dm_t dm;
79 
80 static amxd_object_t* test_build_dm(void) {
81  amxd_object_t* object = NULL;
82  amxd_object_t* sub_object = NULL;
83  amxd_param_t* param = NULL;
84 
85  assert_int_equal(amxd_dm_init(&dm), 0);
86 
87  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObject"), 0);
88  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
89  assert_int_equal(amxd_param_new(&param, "Text", AMXC_VAR_ID_CSTRING), 0);
90  assert_int_equal(amxd_object_add_param(object, param), 0);
91  assert_int_equal(amxd_param_new(&param, "Number", AMXC_VAR_ID_INT32), 0);
92  assert_int_equal(amxd_object_add_param(object, param), 0);
93  assert_int_equal(amxd_param_new(&param, "Reference", AMXC_VAR_ID_CSV_STRING), 0);
94  assert_int_equal(amxd_object_add_param(object, param), 0);
95  assert_int_equal(amxd_param_new(&param, "CsvText", AMXC_VAR_ID_CSV_STRING), 0);
96  assert_int_equal(amxd_object_add_param(object, param), 0);
97  assert_int_equal(amxd_object_new(&sub_object, amxd_object_singleton, "SubObject"), 0);
98  assert_int_equal(amxd_object_add_object(object, sub_object), 0);
99  assert_int_equal(amxd_param_new(&param, "Number", AMXC_VAR_ID_INT32), 0);
100  assert_int_equal(amxd_object_add_param(sub_object, param), 0);
101 
102  return object;
103 }
104 
105 void test_amxd_param_validate_min(UNUSED void** state) {
106  amxd_object_t* object = NULL;
107  amxd_param_t* param = NULL;
108  amxc_var_t* data;
109  amxc_var_t value;
110 
111  amxc_var_new(&data);
112  amxc_var_set(uint32_t, data, 10);
113 
114  amxc_var_init(&value);
115 
116  object = test_build_dm();
117  param = amxd_object_get_param_def(object, "Text");
118  amxc_var_set(cstring_t, &value, "abcdefghij");
119  amxd_param_set_value(param, &value);
120  assert_int_equal(amxd_param_describe(param, &value), 0);
121  assert_null(GETP_ARG(&value, "validate"));
122  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, data), 0);
123  assert_int_equal(amxd_param_describe(param, &value), 0);
124  amxc_var_dump(&value, STDOUT_FILENO);
125  assert_non_null(GETP_ARG(&value, "validate.check_minimum_length"));
126 
127  amxc_var_set(cstring_t, &value, "");
128  assert_int_not_equal(amxd_param_set_value(param, &value), 0);
129 
130  assert_int_not_equal(amxd_param_validate(param, &value), 0);
131  amxc_var_set(cstring_t, &value, "abcde");
132  assert_int_not_equal(amxd_param_validate(param, &value), 0);
133  amxc_var_set(cstring_t, &value, "abcdefghij");
134  assert_int_equal(amxd_param_validate(param, &value), 0);
135  amxc_var_set(cstring_t, &value, "abcdefghij12345");
136  assert_int_equal(amxd_param_validate(param, &value), 0);
137  amxc_var_set_type(&value, AMXC_VAR_ID_CSTRING);
138  assert_int_not_equal(amxd_param_validate(param, &value), 0);
139 
140  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_minimum), 0);
141  amxc_var_set(cstring_t, &value, "abcde");
142  assert_int_equal(amxd_param_validate(param, &value), 0);
143  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, NULL), 0);
144  assert_int_not_equal(amxd_param_validate(param, &value), 0);
145  amxc_var_set(cstring_t, &value, "abcdefghij");
146  assert_int_not_equal(amxd_param_validate(param, &value), 0);
147  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_minimum), 0);
148 
149  param = amxd_object_get_param_def(object, "Number");
150  amxc_var_set(uint32_t, &value, 10);
151  amxd_param_set_value(param, &value);
152 
153  param = amxd_object_get_param_def(object, "Text");
154  amxc_var_set(cstring_t, &value, "abcdefghij");
155  amxd_param_set_value(param, &value);
156  amxc_var_set(cstring_t, data, "TestObject.Number");
157  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, data), 0);
158 
159  amxc_var_set(cstring_t, &value, "");
160  assert_int_not_equal(amxd_param_set_value(param, &value), 0);
161 
162  assert_int_not_equal(amxd_param_validate(param, &value), 0);
163  amxc_var_set(cstring_t, &value, "abcde");
164  assert_int_not_equal(amxd_param_validate(param, &value), 0);
165  amxc_var_set(cstring_t, &value, "abcdefghij");
166  assert_int_equal(amxd_param_validate(param, &value), 0);
167  amxc_var_set(cstring_t, &value, "abcdefghij12345");
168  assert_int_equal(amxd_param_validate(param, &value), 0);
169 
170  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_minimum), 0);
171 
172  param = amxd_object_get_param_def(object, "Number");
173  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, data), 0);
174 
175  amxc_var_set(uint64_t, &value, 5);
176  assert_int_not_equal(amxd_param_validate(param, &value), 0);
177  amxc_var_set(uint64_t, &value, 10);
178  assert_int_equal(amxd_param_validate(param, &value), 0);
179  amxc_var_set(uint64_t, &value, 15);
180  assert_int_equal(amxd_param_validate(param, &value), 0);
181 
182  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_minimum), 0);
183  amxc_var_set(int32_t, &value, 5);
184  assert_int_equal(amxd_param_validate(param, &value), 0);
185 
186  param = amxd_object_get_param_def(object, "Reference");
187  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, data), 0);
188  amxc_var_set(cstring_t, &value, "foo,bar");
189  assert_int_not_equal(amxd_param_validate(param, &value), 0);
190  amxc_var_set(cstring_t, &value, "foo,bar,foo,bar");
191  assert_int_equal(amxd_param_validate(param, &value), 0);
192 
193  amxc_var_delete(&data);
194  amxc_var_clean(&value);
195  amxd_dm_clean(&dm);
196 }
197 
198 void test_amxd_param_validate_max(UNUSED void** state) {
199  amxd_object_t* object = NULL;
200  amxd_object_t* sub_object = NULL;
201  amxd_param_t* param = NULL;
202  amxc_var_t* data;
203  amxc_var_t value;
204 
205  amxc_var_init(&value);
206  amxc_var_new(&data);
207  amxc_var_set(uint32_t, data, 10);
208 
209  object = test_build_dm();
210  param = amxd_object_get_param_def(object, "Text");
211  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_maximum, data), 0);
212  assert_int_equal(amxd_param_describe(param, &value), 0);
213  assert_non_null(GETP_ARG(&value, "validate.check_maximum_length"));
214 
215  assert_int_not_equal(amxd_param_validate(param, &value), 0);
216  amxc_var_set(cstring_t, &value, "abcde");
217  assert_int_equal(amxd_param_validate(param, &value), 0);
218  amxc_var_set(cstring_t, &value, "abcdefghij");
219  assert_int_equal(amxd_param_validate(param, &value), 0);
220  amxc_var_set(cstring_t, &value, "abcdefghij12345");
221  assert_int_not_equal(amxd_param_validate(param, &value), 0);
222 
223  amxc_var_set_type(&value, AMXC_VAR_ID_CSTRING);
224  assert_int_equal(amxd_param_validate(param, &value), 0);
225 
226  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_maximum), 0);
227  amxc_var_set(cstring_t, &value, "abcdefghij12345");
228  assert_int_equal(amxd_param_validate(param, &value), 0);
229  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_maximum, NULL), 0);
230  assert_int_not_equal(amxd_param_validate(param, &value), 0);
231  amxc_var_set(cstring_t, &value, "abcde");
232  assert_int_not_equal(amxd_param_validate(param, &value), 0);
233 
234  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_maximum), 0);
235 
236  sub_object = amxd_object_get_child(object, "SubObject");
237  param = amxd_object_get_param_def(sub_object, "Number");
238  amxc_var_set(uint32_t, &value, 10);
239  amxd_param_set_value(param, &value);
240 
241  param = amxd_object_get_param_def(object, "Text");
242  amxc_var_set(cstring_t, &value, "abcdefghij");
243  amxd_param_set_value(param, &value);
244  amxc_var_set(cstring_t, data, ".SubObject.Number");
245  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_maximum, data), 0);
246 
247  amxc_var_set(cstring_t, &value, "abcde");
248  assert_int_equal(amxd_param_validate(param, &value), 0);
249  amxc_var_set(cstring_t, &value, "abcdefghij");
250  assert_int_equal(amxd_param_validate(param, &value), 0);
251  amxc_var_set(cstring_t, &value, "abcdefghij12345");
252  assert_int_not_equal(amxd_param_validate(param, &value), 0);
253  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_maximum), 0);
254 
255  param = amxd_object_get_param_def(object, "Number");
256  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_maximum, data), 0);
257 
258  amxc_var_set(uint64_t, &value, 5);
259  assert_int_equal(amxd_param_validate(param, &value), 0);
260  amxc_var_set(uint64_t, &value, 10);
261  assert_int_equal(amxd_param_validate(param, &value), 0);
262  amxc_var_set(uint64_t, &value, 15);
263  assert_int_not_equal(amxd_param_validate(param, &value), 0);
264 
265  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_maximum), 0);
266  assert_int_equal(amxd_param_validate(param, &value), 0);
267 
268  param = amxd_object_get_param_def(object, "Reference");
269  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_maximum, data), 0);
270  amxc_var_set(cstring_t, &value, "foo,bar");
271  assert_int_equal(amxd_param_validate(param, &value), 0);
272  amxc_var_set(cstring_t, &value, "foo,bar,foo,bar");
273  assert_int_not_equal(amxd_param_validate(param, &value), 0);
274 
275  amxc_var_delete(&data);
276  amxc_var_clean(&value);
277  amxd_dm_clean(&dm);
278 }
279 
280 void test_amxd_param_validate_range_table(UNUSED void** state) {
281  amxd_object_t* object = NULL;
282  amxd_param_t* param = NULL;
283  amxc_var_t* data;
284  amxc_var_t value;
285 
286  amxc_var_init(&value);
287  amxc_var_new(&data);
288  amxc_var_set_type(data, AMXC_VAR_ID_HTABLE);
289  amxc_var_add_key(uint32_t, data, "min", 10);
290  amxc_var_add_key(uint32_t, data, "max", 20);
291 
292  object = test_build_dm();
293  param = amxd_object_get_param_def(object, "Text");
294  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
295  assert_int_equal(amxd_param_describe(param, &value), 0);
296  assert_non_null(GETP_ARG(&value, "validate.check_range"));
297 
298  assert_int_not_equal(amxd_param_validate(param, &value), 0);
299  amxc_var_set(cstring_t, &value, "abcde");
300  assert_int_not_equal(amxd_param_validate(param, &value), 0);
301  amxc_var_set(cstring_t, &value, "abcdefghij");
302  assert_int_equal(amxd_param_validate(param, &value), 0);
303  amxc_var_set(cstring_t, &value, "abcdefghij12345");
304  assert_int_equal(amxd_param_validate(param, &value), 0);
305  amxc_var_set(cstring_t, &value, "abcdefghij1234567890");
306  assert_int_equal(amxd_param_validate(param, &value), 0);
307  amxc_var_set(cstring_t, &value, "abcdefghijklmnopqrstuvwxyz");
308  assert_int_not_equal(amxd_param_validate(param, &value), 0);
309 
310  amxc_var_set_type(&value, AMXC_VAR_ID_CSTRING);
311  assert_int_not_equal(amxd_param_validate(param, &value), 0);
312 
313  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_range), 0);
314  amxc_var_set(cstring_t, &value, "abcde");
315  assert_int_equal(amxd_param_validate(param, &value), 0);
316  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, NULL), 0);
317  assert_int_not_equal(amxd_param_validate(param, &value), 0);
318  amxc_var_set(cstring_t, &value, "abcdefghijkl");
319  assert_int_not_equal(amxd_param_validate(param, &value), 0);
320 
321  param = amxd_object_get_param_def(object, "Number");
322  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
323 
324  amxc_var_set(uint64_t, &value, 5);
325  assert_int_not_equal(amxd_param_validate(param, &value), 0);
326  amxc_var_set(uint64_t, &value, 10);
327  assert_int_equal(amxd_param_validate(param, &value), 0);
328  amxc_var_set(uint64_t, &value, 15);
329  assert_int_equal(amxd_param_validate(param, &value), 0);
330  amxc_var_set(uint64_t, &value, 20);
331  assert_int_equal(amxd_param_validate(param, &value), 0);
332  amxc_var_set(uint64_t, &value, 26);
333  assert_int_not_equal(amxd_param_validate(param, &value), 0);
334 
335  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_range), 0);
336  assert_int_equal(amxd_param_validate(param, &value), 0);
337 
338  amxc_var_clean(data);
339  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
340  amxc_var_set(uint64_t, &value, 10);
341  assert_int_not_equal(amxd_param_validate(param, &value), 0);
342 
343  amxc_var_delete(&data);
344  amxc_var_clean(&value);
345  amxd_dm_clean(&dm);
346 }
347 
348 void test_amxd_param_validate_range_list(UNUSED void** state) {
349  amxd_object_t* object = NULL;
350  amxd_param_t* param = NULL;
351  amxc_var_t* data;
352  amxc_var_t value;
353 
354  amxc_var_new(&data);
355  amxc_var_set_type(data, AMXC_VAR_ID_LIST);
356  amxc_var_add(uint32_t, data, 10);
357  amxc_var_add(uint32_t, data, 20);
358 
359  object = test_build_dm();
360  param = amxd_object_get_param_def(object, "Text");
361  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
362 
363  amxc_var_init(&value);
364  assert_int_not_equal(amxd_param_validate(param, &value), 0);
365  amxc_var_set(cstring_t, &value, "abcde");
366  assert_int_not_equal(amxd_param_validate(param, &value), 0);
367  amxc_var_set(cstring_t, &value, "abcdefghij");
368  assert_int_equal(amxd_param_validate(param, &value), 0);
369  amxc_var_set(cstring_t, &value, "abcdefghij12345");
370  assert_int_equal(amxd_param_validate(param, &value), 0);
371  amxc_var_set(cstring_t, &value, "abcdefghij1234567890");
372  assert_int_equal(amxd_param_validate(param, &value), 0);
373  amxc_var_set(cstring_t, &value, "abcdefghijklmnopqrstuvwxyz");
374  assert_int_not_equal(amxd_param_validate(param, &value), 0);
375 
376  amxc_var_set_type(&value, AMXC_VAR_ID_CSTRING);
377  assert_int_not_equal(amxd_param_validate(param, &value), 0);
378 
379  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_range), 0);
380  amxc_var_set(cstring_t, &value, "abcde");
381  assert_int_equal(amxd_param_validate(param, &value), 0);
382  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, NULL), 0);
383  assert_int_not_equal(amxd_param_validate(param, &value), 0);
384  amxc_var_set(cstring_t, &value, "abcdefghijkl");
385  assert_int_not_equal(amxd_param_validate(param, &value), 0);
386 
387  param = amxd_object_get_param_def(object, "Number");
388  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
389 
390  amxc_var_set(uint64_t, &value, 5);
391  assert_int_not_equal(amxd_param_validate(param, &value), 0);
392  amxc_var_set(uint64_t, &value, 10);
393  assert_int_equal(amxd_param_validate(param, &value), 0);
394  amxc_var_set(uint64_t, &value, 15);
395  assert_int_equal(amxd_param_validate(param, &value), 0);
396  amxc_var_set(uint64_t, &value, 20);
397  assert_int_equal(amxd_param_validate(param, &value), 0);
398  amxc_var_set(uint64_t, &value, 26);
399  assert_int_not_equal(amxd_param_validate(param, &value), 0);
400 
401  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_range), 0);
402  assert_int_equal(amxd_param_validate(param, &value), 0);
403 
404  amxc_var_clean(data);
405  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
406  amxc_var_set(uint64_t, &value, 10);
407  assert_int_not_equal(amxd_param_validate(param, &value), 0);
408 
409  amxc_var_delete(&data);
410  amxc_var_clean(&value);
411  amxd_dm_clean(&dm);
412 }
413 
414 void test_amxd_param_validate_range_invalid(UNUSED void** state) {
415  amxd_object_t* object = NULL;
416  amxd_param_t* param = NULL;
417  amxc_var_t* data;
418  amxc_var_t value;
419 
420  amxc_var_new(&data);
421  amxc_var_set_type(data, AMXC_VAR_ID_LIST);
422  amxc_var_add(uint32_t, data, 20);
423  amxc_var_add(uint32_t, data, 10);
424 
425  object = test_build_dm();
426  param = amxd_object_get_param_def(object, "Text");
427  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
428 
429  amxc_var_init(&value);
430  assert_int_not_equal(amxd_param_validate(param, &value), 0);
431  amxc_var_set(cstring_t, &value, "abcde");
432  assert_int_not_equal(amxd_param_validate(param, &value), 0);
433  amxc_var_set(cstring_t, &value, "abcdefghijkl");
434  assert_int_not_equal(amxd_param_validate(param, &value), 0);
435  amxc_var_set(cstring_t, &value, "abcdefghijklmnopqrstuv");
436  assert_int_not_equal(amxd_param_validate(param, &value), 0);
437 
438  param = amxd_object_get_param_def(object, "Number");
439  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_range, data), 0);
440 
441  amxc_var_set(uint64_t, &value, 5);
442  assert_int_not_equal(amxd_param_validate(param, &value), 0);
443  amxc_var_set(uint64_t, &value, 15);
444  assert_int_not_equal(amxd_param_validate(param, &value), 0);
445  amxc_var_set(uint64_t, &value, 25);
446  assert_int_not_equal(amxd_param_validate(param, &value), 0);
447 
448  amxc_var_delete(&data);
449  amxc_var_clean(&value);
450  amxd_dm_clean(&dm);
451 }
452 
453 void test_amxd_param_validate_enum(UNUSED void** state) {
454  amxd_object_t* object = NULL;
455  amxd_param_t* param = NULL;
456  amxc_var_t* data;
457  amxc_var_t value;
458 
459  object = test_build_dm();
460 
461  amxc_var_init(&value);
462  amxc_var_new(&data);
463  amxc_var_set_type(data, AMXC_VAR_ID_LIST);
464  amxc_var_add(int32_t, data, 10);
465  amxc_var_add(uint64_t, data, 20);
466  amxc_var_add(int64_t, data, -10);
467  amxc_var_add(int64_t, data, -20);
468 
469  param = amxd_object_get_param_def(object, "Number");
470  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_enum, data), 0);
471  assert_int_equal(amxd_param_describe(param, &value), 0);
472  assert_non_null(GETP_ARG(&value, "validate.check_enum"));
473 
474  assert_int_not_equal(amxd_param_validate(param, &value), 0);
475  amxc_var_set(uint64_t, &value, 5);
476  assert_int_not_equal(amxd_param_validate(param, &value), 0);
477  amxc_var_set(uint64_t, &value, 10);
478  assert_int_equal(amxd_param_validate(param, &value), 0);
479  amxc_var_set(int64_t, &value, -5);
480  assert_int_not_equal(amxd_param_validate(param, &value), 0);
481  amxc_var_set(int64_t, &value, -20);
482  assert_int_equal(amxd_param_validate(param, &value), 0);
483  amxc_var_set(int32_t, &value, -10);
484  assert_int_equal(amxd_param_validate(param, &value), 0);
485  amxc_var_set(uint32_t, &value, 0);
486  assert_int_not_equal(amxd_param_validate(param, &value), 0);
487 
488  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_enum), 0);
489  assert_int_equal(amxd_param_validate(param, &value), 0);
490 
491  amxc_var_clean(data);
492  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_enum, data), 0);
493  amxc_var_set(uint64_t, &value, 10);
494  assert_int_not_equal(amxd_param_validate(param, &value), 0);
495 
496  amxc_var_delete(&data);
497  amxc_var_clean(&value);
498  amxd_dm_clean(&dm);
499 }
500 
501 void test_amxd_param_csv_validate_enum(UNUSED void** state) {
502  amxd_object_t* object = NULL;
503  amxd_param_t* param = NULL;
504  amxc_var_t* data;
505  amxc_var_t value;
506 
507  object = test_build_dm();
508 
509  amxc_var_new(&data);
510  amxc_var_set_type(data, AMXC_VAR_ID_LIST);
511  amxc_var_add(int32_t, data, 10);
512  amxc_var_add(uint64_t, data, 20);
513  amxc_var_add(int64_t, data, -10);
514  amxc_var_add(int64_t, data, -20);
515 
516  param = amxd_object_get_param_def(object, "CsvText");
517  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_enum, data), 0);
518 
519  amxc_var_init(&value);
520  assert_int_not_equal(amxd_param_validate(param, &value), 0);
521  amxc_var_set(uint64_t, &value, 5);
522  assert_int_not_equal(amxd_param_validate(param, &value), 0);
523  amxc_var_set(uint64_t, &value, 10);
524  assert_int_equal(amxd_param_validate(param, &value), 0);
525  amxc_var_set(cstring_t, &value, "-5, 10");
526  assert_int_not_equal(amxd_param_validate(param, &value), 0);
527  amxc_var_set(cstring_t, &value, "-20, 20");
528  assert_int_equal(amxd_param_validate(param, &value), 0);
529  amxc_var_set(int32_t, &value, -10);
530  assert_int_equal(amxd_param_validate(param, &value), 0);
531  amxc_var_set(uint32_t, &value, 0);
532  assert_int_not_equal(amxd_param_validate(param, &value), 0);
533 
534  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_enum), 0);
535  assert_int_equal(amxd_param_validate(param, &value), 0);
536 
537  amxc_var_clean(data);
538  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_enum, data), 0);
539  amxc_var_set(uint64_t, &value, 10);
540  assert_int_not_equal(amxd_param_validate(param, &value), 0);
541 
542  amxc_var_delete(&data);
543  amxc_var_clean(&value);
544  amxd_dm_clean(&dm);
545 }
546 
547 void test_amxd_param_validate_reference(UNUSED void** state) {
548  amxd_object_t* object = NULL;
549  amxd_param_t* param = NULL;
550  amxc_var_t* data;
551  amxc_var_t value;
552  uint8_t i;
553  const char* data_list[2] = {"TestObject.Reference", ".Reference"};
554 
555  for(i = 0; i < 2; i++) {
556  object = test_build_dm();
557 
558  amxc_var_init(&value);
559  amxc_var_new(&data);
560  amxc_var_set(cstring_t, data, data_list[i]);
561 
562  param = amxd_object_get_param_def(object, "Text");
563  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_is_in, data), 0);
564  assert_int_equal(amxd_param_describe(param, &value), 0);
565  assert_non_null(GETP_ARG(&value, "validate.check_is_in"));
566 
567  amxc_var_clean(&value); // reset value to NULL variant
568  assert_int_not_equal(amxd_param_validate(param, &value), 0);
569  amxc_var_set(cstring_t, &value, "universe");
570  assert_int_equal(amxd_param_validate(param, &value), 0);
571 
572  amxd_object_set_value(csv_string_t, object, "Reference", "hello,world,and,universe");
573  assert_int_equal(amxd_param_validate(param, &value), 0);
574 
575  amxc_var_set(cstring_t, &value, "silly text");
576  assert_int_not_equal(amxd_param_validate(param, &value), 0);
577  amxc_var_set(cstring_t, &value, "hello");
578  assert_int_equal(amxd_param_validate(param, &value), 0);
579  amxc_var_set(cstring_t, &value, "Brussels");
580  assert_int_not_equal(amxd_param_validate(param, &value), 0);
581  amxc_var_set(cstring_t, &value, "and");
582  assert_int_equal(amxd_param_validate(param, &value), 0);
583  amxc_var_set(cstring_t, &value, "world");
584  assert_int_equal(amxd_param_validate(param, &value), 0);
585  amxc_var_set(cstring_t, &value, "France");
586  assert_int_not_equal(amxd_param_validate(param, &value), 0);
587 
588  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_is_in), 0);
589  assert_int_equal(amxd_param_validate(param, &value), 0);
590 
591  amxc_var_clean(data);
592  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_is_in, data), 0);
593  amxc_var_set(cstring_t, &value, "Europe");
594  assert_int_not_equal(amxd_param_validate(param, &value), 0);
595 
596  amxc_var_delete(&data);
597  amxc_var_clean(&value);
598  amxd_dm_clean(&dm);
599  }
600 }
601 
602 void test_amxd_param_csv_validate_reference(UNUSED void** state) {
603  amxd_object_t* object = NULL;
604  amxd_param_t* param = NULL;
605  amxc_var_t* data;
606  amxc_var_t value;
607 
608  uint8_t i;
609  const char* data_list[2] = {"TestObject.Reference", ".Reference"};
610 
611  for(i = 0; i < 2; i++) {
612  object = test_build_dm();
613 
614  amxc_var_new(&data);
615  amxc_var_set(cstring_t, data, data_list[i]);
616 
617  param = amxd_object_get_param_def(object, "CsvText");
618  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_is_in, data), 0);
619 
620  amxc_var_init(&value);
621  assert_int_not_equal(amxd_param_validate(param, &value), 0);
622  amxc_var_set(cstring_t, &value, "universe,world");
623  assert_int_equal(amxd_param_validate(param, &value), 0);
624 
625  amxd_object_set_value(csv_string_t, object, "Reference", "hello,world,and,universe");
626  assert_int_equal(amxd_param_validate(param, &value), 0);
627 
628  amxc_var_set(cstring_t, &value, "univers,silly text");
629  assert_int_not_equal(amxd_param_validate(param, &value), 0);
630  amxc_var_set(cstring_t, &value, "world,hello");
631  assert_int_equal(amxd_param_validate(param, &value), 0);
632  amxc_var_set(cstring_t, &value, "Brussels,Paris");
633  assert_int_not_equal(amxd_param_validate(param, &value), 0);
634  amxc_var_set(cstring_t, &value, "world,and,universe");
635  assert_int_equal(amxd_param_validate(param, &value), 0);
636  amxc_var_set(cstring_t, &value, "world");
637  assert_int_equal(amxd_param_validate(param, &value), 0);
638  amxc_var_set(cstring_t, &value, "France");
639  assert_int_not_equal(amxd_param_validate(param, &value), 0);
640 
641  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_is_in), 0);
642  assert_int_equal(amxd_param_validate(param, &value), 0);
643 
644  amxc_var_clean(data);
645  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_is_in, data), 0);
646  amxc_var_set(cstring_t, &value, "Europe");
647  assert_int_not_equal(amxd_param_validate(param, &value), 0);
648 
649  amxc_var_delete(&data);
650  amxc_var_clean(&value);
651  amxd_dm_clean(&dm);
652  }
653 }
654 
655 void test_amxd_param_validate_invalid_reference(UNUSED void** state) {
656  amxd_object_t* object = NULL;
657  amxd_param_t* param = NULL;
658  amxc_var_t* data;
659  amxc_var_t value;
660 
661  uint8_t i;
662  const char* data_list[2] = {"TestObject.InvalidReference", "InvalidReference"};
663 
664  for(i = 0; i < 2; i++) {
665  object = test_build_dm();
666 
667  amxc_var_new(&data);
668  amxc_var_set(cstring_t, data, data_list[i]);
669 
670  param = amxd_object_get_param_def(object, "Text");
671  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_is_in, data), 0);
672 
673  amxc_var_init(&value);
674  assert_int_not_equal(amxd_param_validate(param, &value), 0);
675  amxc_var_set(cstring_t, &value, "universe");
676  assert_int_not_equal(amxd_param_validate(param, &value), 0);
677  amxc_var_set(cstring_t, &value, "silly text");
678  assert_int_not_equal(amxd_param_validate(param, &value), 0);
679  amxc_var_set(cstring_t, &value, "hello");
680  assert_int_not_equal(amxd_param_validate(param, &value), 0);
681  amxc_var_set(cstring_t, &value, "Brussels");
682  assert_int_not_equal(amxd_param_validate(param, &value), 0);
683  amxc_var_set(cstring_t, &value, "and");
684  assert_int_not_equal(amxd_param_validate(param, &value), 0);
685  amxc_var_set(cstring_t, &value, "world");
686  assert_int_not_equal(amxd_param_validate(param, &value), 0);
687  amxc_var_set(cstring_t, &value, "France");
688  assert_int_not_equal(amxd_param_validate(param, &value), 0);
689 
690  assert_int_equal(amxd_param_remove_action_cb(param, action_param_validate, amxd_action_param_check_is_in), 0);
691  amxc_var_set(cstring_t, data, "TestObject.InvalidReference.");
692  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_is_in, data), 0);
693  amxc_var_set(cstring_t, &value, "Brussels");
694  assert_int_not_equal(amxd_param_validate(param, &value), 0);
695 
696  amxc_var_delete(&data);
697  amxc_var_clean(&value);
698  amxd_dm_clean(&dm);
699  }
700 }
701 
702 void test_amxd_param_validate_wrong_action(UNUSED void** state) {
703  amxd_object_t* object = NULL;
704  amxd_param_t* param = NULL;
705  amxc_var_t* data;
706  amxc_var_t value;
707 
708  object = test_build_dm();
709 
710  amxc_var_new(&data);
711  amxc_var_set_type(data, AMXC_VAR_ID_LIST);
712  amxc_var_add(int32_t, data, 10);
713  amxc_var_add(uint64_t, data, 20);
714  amxc_var_add(int64_t, data, -10);
715  amxc_var_add(int64_t, data, -20);
716 
717  param = amxd_object_get_param_def(object, "Number");
718  assert_int_equal(amxd_param_add_action_cb(param, action_param_write, amxd_action_param_check_enum, data), 0);
719 
720  amxc_var_init(&value);
721  amxc_var_set(uint64_t, &value, 5);
722  assert_int_equal(amxd_param_validate(param, &value), 0);
723  assert_int_equal(amxd_param_set_value(param, &value), 0);
724 
725  amxc_var_delete(&data);
726  amxc_var_clean(&value);
727  amxd_dm_clean(&dm);
728 }
amxd_action.h
Ambiorix Data Model Default actions header file.
amxd_common.h
amxd_dm.h
Ambiorix Data Model API header file.
amxd_function.h
Ambiorix Data Model RPC methods API header file.
amxd_object.h
Ambiorix Data Model API header file.
amxd_parameter.h
amxd_param_describe
amxd_status_t amxd_param_describe(amxd_param_t *const param, amxc_var_t *const value)
Definition: amxd_action_param_describe.c:181
amxd_param_validate
amxd_status_t amxd_param_validate(amxd_param_t *const param, const amxc_var_t *const value)
Definition: amxd_action_param_validate.c:448
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_value
amxd_status_t amxd_param_set_value(amxd_param_t *const param, const amxc_var_t *const value)
Definition: amxd_action_param_write.c:113
amxd_param_add_action_cb
amxd_status_t amxd_param_add_action_cb(amxd_param_t *const param, const amxd_action_t reason, amxd_action_fn_t fn, void *priv)
Definition: amxd_parameter_action.c:67
amxd_param_remove_action_cb
amxd_status_t amxd_param_remove_action_cb(amxd_param_t *const param, const amxd_action_t reason, amxd_action_fn_t fn)
Definition: amxd_parameter_action.c:96
action_param_write
@ action_param_write
Definition: amxd_types.h:113
action_param_validate
@ action_param_validate
Definition: amxd_types.h:114
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_dm_clean
void amxd_dm_clean(amxd_dm_t *dm)
Cleans a data model structure.
Definition: amxd_dm.c:365
amxd_object_get_child
amxd_object_t * amxd_object_get_child(const amxd_object_t *object, const char *name)
Get a child of the object.
Definition: amxd_object_hierarchy.c:299
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_set_value
#define amxd_object_set_value(type, object, name, value)
Helper macro for setting a value.
Definition: amxd_object_parameter.h:85
amxd_object_get_param_def
amxd_param_t * amxd_object_get_param_def(const amxd_object_t *const object, const char *name)
Gets a parameter definition from an object.
Definition: amxd_object_parameter.c:146
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_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_action_param_check_range
amxd_status_t amxd_action_param_check_range(amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default check range parameter validate action implementation.
Definition: amxd_action_param_validate.c:262
amxd_action_param_check_is_in
amxd_status_t amxd_action_param_check_is_in(amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default check is in parameter validate action implementation.
Definition: amxd_action_param_validate.c:404
amxd_action_param_check_enum
amxd_status_t amxd_action_param_check_enum(amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default check enum parameter validate action implementation.
Definition: amxd_action_param_validate.c:369
amxd_action_param_check_maximum
amxd_status_t amxd_action_param_check_maximum(amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default check maximum parameter validate action implementation.
Definition: amxd_action_param_validate.c:335
amxd_action_param_check_minimum
amxd_status_t amxd_action_param_check_minimum(amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default check minimum parameter validate action implementation.
Definition: amxd_action_param_validate.c:302
_amxd_dm
Definition: amxd_types.h:259
_amxd_object
Definition: amxd_types.h:229
_amxd_parameter
Definition: amxd_types.h:386
test_amxd_param_validate_reference
void test_amxd_param_validate_reference(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:547
test_amxd_param_validate_wrong_action
void test_amxd_param_validate_wrong_action(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:702
test_amxd_param_csv_validate_enum
void test_amxd_param_csv_validate_enum(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:501
test_amxd_param_validate_range_invalid
void test_amxd_param_validate_range_invalid(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:414
test_amxd_param_validate_max
void test_amxd_param_validate_max(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:198
dm
static amxd_dm_t dm
Definition: test_amxd_parameter_validation.c:78
test_amxd_param_validate_invalid_reference
void test_amxd_param_validate_invalid_reference(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:655
test_amxd_param_validate_enum
void test_amxd_param_validate_enum(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:453
test_amxd_param_validate_min
void test_amxd_param_validate_min(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:105
test_amxd_param_validate_range_list
void test_amxd_param_validate_range_list(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:348
test_amxd_param_csv_validate_reference
void test_amxd_param_csv_validate_reference(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:602
test_build_dm
static amxd_object_t * test_build_dm(void)
Definition: test_amxd_parameter_validation.c:80
test_amxd_param_validate_range_table
void test_amxd_param_validate_range_table(UNUSED void **state)
Definition: test_amxd_parameter_validation.c:280
test_amxd_parameter_validation.h