blob: 29bb1f47de59d31f973b17f8cca8ab9a03bf49a3 [file] [log] [blame]
Radek Iša56ca9e42020-09-08 18:42:00 +02001/**
2 * @file utests.h
3 * @author Radek Iša <isa@cesnet.cz>
4 * @author Radek Krejci <rkrejci@cesnet.cz>
5 * @brief this file contains macros for simplification test writing
6 *
Radek Išaa9ff2b82021-01-13 21:44:13 +01007 * Copyright (c) 2021 CESNET, z.s.p.o.
Radek Iša56ca9e42020-09-08 18:42:00 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
16#ifndef _UTESTS_H_
17#define _UTESTS_H_
18
19#define _POSIX_C_SOURCE 200809L /* strdup */
20
Radek Krejcib4ac5a92020-11-23 17:54:33 +010021#include <setjmp.h>
22#include <stdarg.h>
23#include <stddef.h>
Antonio Prcelafe128282022-08-24 11:36:34 +020024#include <stdint.h>
Michal Vasko86421632021-05-04 13:11:25 +020025#include <stdlib.h>
Radek Krejcib4ac5a92020-11-23 17:54:33 +010026
27#include <cmocka.h>
Radek Iša56ca9e42020-09-08 18:42:00 +020028
29#include <string.h>
30
31#include "libyang.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010032#include "plugins_internal.h"
Radek Išaa9ff2b82021-01-13 21:44:13 +010033#include "plugins_types.h"
Radek Krejcief5f7672021-04-01 17:04:12 +020034#include "tests_config.h"
Radek Išaa9ff2b82021-01-13 21:44:13 +010035#include "tree_schema_internal.h"
Radek Iša56ca9e42020-09-08 18:42:00 +020036
37/**
38 * TESTS OVERVIEW
39 *
40 * To include utest's environment, just include "utests.h" in the test's source
41 * code. In case it is the main source code for a cmocka test group (there is a
42 * main() function), define _UTEST_MAIN_ before including this header.
43 *
44 * TESTS VARIABLES
45 *
46 * Checking macros use internal storage to store various variables necessary
47 * during the checking. It is possible to access these variables using the
48 * following macros:
49 *
50 * UTEST_LYCTX - libyang context
51 * UTEST_IN - input handler
52 * UTEST_OUT - output handler
53 *
54 * All these variables are cleaned with test's teardown.
55 *
56 * TESTS SETUP
57 *
58 * CMocka's CMUnitTest list definition macros (cmoka_unit_test*()) are replaced
59 * by UTEST macro with possibility to specify own setup and teardown functions:
60 *
61 * UTEST(test_func) - only implicit setup and teardown functions are used
62 * UTEST(test_func, setup) - implicit teardown but own setup
63 * UTEST(test_func, setup, teardown) - both setup and teardown are test-specific
64 *
65 * Note that the tests environment always provide (and need) internal setup and
66 * teardown functions. In case the test-specific setup or teardown are used, they
67 * are supposed to include UTEST_SETUP at the setup beginning and UTEST_TEARDOWN
68 * at the teardown end.
69 *
70 * Libyang context is part of the prepared environment. To add a schema into the
71 * context (despite it is in the test-specific setup or in test function itself),
72 * use UTEST_ADD_MODULE macro.
73 *
74 * LOGGING
75 *
76 * There are 2 macros to check content of the log from the previously called
77 * libyang function. CHECK_LOG macro test only the last error message and path
78 * stored directly via logging callback. CHECK_LOG_CTX gets error message and
79 * path from the libyang context (in case the function does not store the error
80 * information into the libyang context, the message cannot be checked this way).
81 * libyang is set to store multiple error information, so multiple couples of
82 * error message and path can be provided to be checked (the first couple
83 * corresponds to the latest error). The macro also cleanups the errors list, so
84 * it is fine to check that there is no error after succeeding successful
85 * function call.
86 */
87
88/**
89 * @brief Test's context to provide common storage for various variables.
90 */
91struct utest_context {
92 struct ly_ctx *ctx; /**< libyang context */
93
94 char *err_msg; /**< Directly logged error message */
95 char *err_path; /**< Directly logged error path */
96
97 struct ly_in *in; /**< Input handler */
98 struct ly_out *out; /**< Outpu handler */
Michal Vasko86421632021-05-04 13:11:25 +020099
100 char *orig_tz; /**< Original "TZ" environment variable value */
Radek Iša56ca9e42020-09-08 18:42:00 +0200101};
102
103/**
104 * @brief Shortcut to access utest_context.
105 */
106#define _UC ((struct utest_context *)*state)
107
108/**
109 * @brief libyang context provider.
110 */
111#define UTEST_LYCTX (_UC->ctx)
112
113/**
114 * @brief Context's input handler provider
115 */
116#define UTEST_IN (_UC->in)
117
118/**
119 * @brief Context's input handler provider
120 */
121#define UTEST_OUT (_UC->out)
122
123/**
124 * @brief Parse (and validate) data from the input handler as a YANG data tree.
125 *
126 * @param[in] INPUT The input data in the specified @p format to parse (and validate)
127 * @param[in] INPUT_FORMAT Format of the input data to be parsed. Can be 0 to try to detect format from the input handler.
128 * @param[in] PARSE_OPTIONS Options for parser, see @ref dataparseroptions.
129 * @param[in] VALIDATE_OPTIONS Options for the validation phase, see @ref datavalidationoptions.
Michal Vaskoddd76592022-01-17 13:34:48 +0100130 * @param[in] RET expected return status
131 * @param[out] OUT_NODE Resulting data tree built from the input data. Note that NULL can be a valid result as a
132 * representation of an empty YANG data tree.
Radek Iša56ca9e42020-09-08 18:42:00 +0200133 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100134#define CHECK_PARSE_LYD_PARAM(INPUT, INPUT_FORMAT, PARSE_OPTIONS, VALIDATE_OPTIONS, RET, OUT_NODE) \
135 { \
136 LY_ERR _r = lyd_parse_data_mem(_UC->ctx, INPUT, INPUT_FORMAT, PARSE_OPTIONS, VALIDATE_OPTIONS, &OUT_NODE); \
137 if (_r != RET) { \
138 if (_r) { \
139 fail_msg("%s != 0x%d; MSG: %s", #RET, _r, ly_err_last(_UC->ctx)->msg); \
140 } else { \
141 fail_msg("%s != 0x%d", #RET, _r); \
142 } \
143 } \
Radek Iša56ca9e42020-09-08 18:42:00 +0200144 }
145
146/**
147 * @brief Check if lyd_node and his subnodes have correct values. Print lyd_node and his sunodes int o string in json or xml format.
148 * @param[in] NODE pointer to lyd_node
149 * @param[in] TEXT expected output string in json or xml format.
150 * @param[in] FORMAT format of input text. LYD_JSON, LYD_XML
151 * @param[in] PARAM options [Data printer flags](@ref dataprinterflags).
152 */
153#define CHECK_LYD_STRING_PARAM(NODE, TEXT, FORMAT, PARAM) \
154 { \
Michal Vaskoddd76592022-01-17 13:34:48 +0100155 char *str; \
156 LY_ERR _r = lyd_print_mem(&str, NODE, FORMAT, PARAM); \
157 if (_r) { \
158 fail_msg("Print err 0x%d; MSG: %s", _r, ly_err_last(_UC->ctx)->msg); \
159 } \
160 assert_string_equal(str, TEXT); \
161 free(str); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200162 }
163
164/**
165 * @brief Compare two lyd_node structure. Macro print lyd_node structure into string and then compare string. Print function use these two parameters. LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK;
166 * @param[in] NODE_1 pointer to lyd_node
167 * @param[in] NODE_2 pointer to lyd_node
168 */
169#define CHECK_LYD(NODE_1, NODE_2) \
170 { \
Michal Vaskoddd76592022-01-17 13:34:48 +0100171 char *str1; \
172 char *str2; \
173 assert_int_equal(LY_SUCCESS, lyd_print_mem(&str1, NODE_1, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK)); \
174 assert_int_equal(LY_SUCCESS, lyd_print_mem(&str2, NODE_2, LYD_XML, LYD_PRINT_WITHSIBLINGS | LYD_PRINT_SHRINK)); \
175 assert_non_null(str1); \
176 assert_non_null(str2); \
177 assert_string_equal(str1, str2); \
178 free(str1); \
179 free(str2); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200180 }
181
182/*
183 * SUPPORT MACROS
184 */
185
186/**
187 * @brief Internal macro witch assert that two given string are equal or are both null.
188 *
189 * @param[in] STRING string to check
190 * @param[in] TEXT string to compare
191 */
192#define CHECK_STRING(STRING, TEXT)\
193 if (TEXT == NULL) { \
194 assert_null(STRING); \
195 } else { \
196 assert_non_null(STRING); \
197 assert_string_equal(STRING, TEXT); \
198 }
199
200/**
201 * @brief Internal macro witch assert that pointer is null when flag is 0.
202 *
203 * @param[in] POINTER pointer to check
204 * @param[in] FLAG 0 -> pointer is NULL, 1 -> pointer is not null
205 */
206#define CHECK_POINTER(POINTER, FLAG) \
207 assert_true(FLAG == 0 ? POINTER == NULL : POINTER != NULL)
208
209/**
210 * @brief Internal macro check size of [sized array](@ref sizedarrays)'s
211 *
212 * @param[in] ARRAY pointer to [sized array](@ref sizedarrays)
213 * @param[in] SIZE expected [sized array](@ref sizedarrays) size of array
214 */
215#define CHECK_ARRAY(ARRAY, SIZE) \
216 assert_true((SIZE == 0) ? \
217 (ARRAY == NULL) : \
218 (ARRAY != NULL && SIZE == LY_ARRAY_COUNT(ARRAY)));
219
220/*
221 * LIBYANG NODE CHECKING
222 */
223
224/**
Radek Išaa9ff2b82021-01-13 21:44:13 +0100225 * @brief check compileted type
Michal Vaskoddd76592022-01-17 13:34:48 +0100226 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100227 * @param[in] NODE pointer to lysc_type value
228 * @param[in] TYPE expected type [LY_DATA_TYPE](@ref LY_DATA_TYPE)
229 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
230 */
231#define CHECK_LYSC_TYPE(NODE, TYPE, EXTS) \
232 assert_non_null(NODE); \
233 assert_int_equal((NODE)->basetype, TYPE); \
234 CHECK_ARRAY((NODE)->exts, EXTS); \
Radek Krejci3e6632f2021-03-22 22:08:21 +0100235 assert_ptr_equal((NODE)->plugin, lyplg_find(LYPLG_TYPE, "", NULL, ly_data_type2str[TYPE]))
Radek Išaa9ff2b82021-01-13 21:44:13 +0100236
Michal Vaskoddd76592022-01-17 13:34:48 +0100237/**
238 * @brief check compileted numeric type
239 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100240 * @param[in] NODE pointer to lysc_type_num value
241 * @param[in] TYPE expected type [LY_DATA_TYPE](@ref LY_DATA_TYPE)
242 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
243 * @warning only integer types INT, UINT, NUM
244 */
245#define CHECK_LYSC_TYPE_NUM(NODE, TYPE, EXTS, RANGE) \
246 CHECK_LYSC_TYPE(NODE, TYPE, EXTS);\
247 CHECK_POINTER((NODE)->range, RANGE)
248
Michal Vaskoddd76592022-01-17 13:34:48 +0100249/**
250 * @brief check compiled string type
251 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100252 * @param[in] NODE pointer to lysc_type_num value
253 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
254 * @param[in] LENGTH 0 -> node dosnt have length limitation, 1 -> node have length limitation
255 * @param[in] PATTERNS expected number of patterns [sized array](@ref sizedarrays)
256 * @warning only integer types INT, UINT, NUM
257 */
258#define CHECK_LYSC_TYPE_STR(NODE, EXTS, LENGTH, PATTERNS) \
259 CHECK_LYSC_TYPE(NODE, LY_TYPE_STRING, EXTS); \
260 CHECK_POINTER((NODE)->length, LENGTH); \
261 CHECK_ARRAY((NODE)->patterns, PATTERNS)
262
Michal Vaskoddd76592022-01-17 13:34:48 +0100263/**
264 * @brief check compiled bits type
265 *
Radek Išaded31052021-03-10 13:22:53 +0100266 * @param[in] NODE pointer to lysc_type_num value
267 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
268 * @param[in] BITS expected number of bits
269 * @warning only integer types INT, UINT, NUM
270 */
271#define CHECK_LYSC_TYPE_BITS(NODE, EXTS, BITS) \
272 CHECK_LYSC_TYPE(NODE, LY_TYPE_BITS, EXTS); \
273 CHECK_ARRAY((NODE)->bits, BITS)
274
Radek Išaded31052021-03-10 13:22:53 +0100275#define CHECK_LYSC_TYPE_BITENUM_ITEM(NODE, POSITION, DSC, EXTS, FLAGS, NAME, REF)\
276 assert_non_null(NODE); \
277 assert_int_equal((NODE)->position, POSITION); \
278 CHECK_STRING((NODE)->dsc, DSC); \
279 CHECK_ARRAY((NODE)->exts, EXTS); \
280 assert_int_equal((NODE)->flags, FLAGS); \
281 CHECK_STRING((NODE)->name, NAME); \
282 CHECK_STRING((NODE)->ref, REF) \
283
Michal Vaskoddd76592022-01-17 13:34:48 +0100284/**
285 * @brief check range
286 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100287 * @param[in] NODE pointer to lysc_range value
288 * @param[in] DSC expected descriptin (string)
289 * @param[in] EAPPTAG expected string reprezenting error-app-tag value
290 * @param[in] EMSG expected string reprezenting error message
291 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
292 * @param[in] PARTS expected [sized array](@ref sizedarrays) number of rang limitations
293 * @param[in] REF expected reference
294 */
295#define CHECK_LYSC_RANGE(NODE, DSC, EAPPTAG, EMSG, EXTS, PARTS, REF) \
296 assert_non_null(NODE); \
297 CHECK_STRING((NODE)->dsc, DSC); \
298 CHECK_STRING((NODE)->eapptag, EAPPTAG); \
299 CHECK_STRING((NODE)->emsg, EMSG); \
300 CHECK_ARRAY((NODE)->exts, EXTS); \
301 CHECK_ARRAY((NODE)->parts, PARTS); \
302 CHECK_STRING((NODE)->ref, REF)
303
Michal Vaskoddd76592022-01-17 13:34:48 +0100304/**
305 * @brief check pattern
306 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100307 * @param[in] NODE pointer to lysc_pattern value
308 * @param[in] DSC expected descriptin (string)
309 * @param[in] EAPPTAG expected string reprezenting error-app-tag value
310 * @param[in] EMSG expected string reprezenting error message
311 * @param[in] EEXPR expected string reprezenting original, not compiled, regular expression
312 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
313 * @param[in] INVERTED if regular expression is inverted.
314 * @param[in] REF expected reference
315 */
316#define CHECK_LYSC_PATTERN(NODE, DSC, EAPPTAG, EMSG, EXPR, EXTS, INVERTED, REF) \
317 assert_non_null(NODE); \
318 assert_non_null((NODE)->code); \
319 CHECK_STRING((NODE)->dsc, DSC); \
320 CHECK_STRING((NODE)->eapptag, EAPPTAG); \
321 CHECK_STRING((NODE)->emsg, EMSG); \
322 CHECK_STRING((NODE)->expr, EXPR); \
323 CHECK_ARRAY((NODE)->exts, EXTS); \
324 assert_int_equal((NODE)->inverted, INVERTED); \
325 CHECK_STRING((NODE)->ref, REF)
326
327/**
Radek Iša56ca9e42020-09-08 18:42:00 +0200328 * @brief assert that lysp_action_inout structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100329 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200330 * @param[in] NODE pointer to lysp_action_inout variable
331 * @param[in] DATA 0 -> check if pointer to data is NULL, 1 -> check if pointer to data is not null
332 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extens list
333 * @param[in] GROUPINGS expected [sized array](@ref sizedarrays) size of grouping list
334 * @param[in] MUSTS expected [sized array](@ref sizedarrays) size of must restriction list
335 * @param[in] NODETYPE node type. LYS_INPUT or LYS_OUTPUT
336 * @param[in] PARENT 0 -> check if node is root, 1 -> check if node is not root
337 * @param[in] TYPEDEFS expected [sized array](@ref sizedarrays) size of typedefs list
338 */
339#define CHECK_LYSP_ACTION_INOUT(NODE, DATA, EXTS, GROUPINGS, MUSTS, NODETYPE, PARENT, TYPEDEFS) \
340 assert_non_null(NODE); \
Radek Krejci01180ac2021-01-27 08:48:22 +0100341 CHECK_POINTER((NODE)->child, DATA); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200342 CHECK_ARRAY((NODE)->exts, EXTS); \
Radek Krejci2a9fc652021-01-22 17:44:34 +0100343 CHECK_POINTER((NODE)->groupings, GROUPINGS); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200344 CHECK_ARRAY((NODE)->musts, MUSTS); \
345 assert_int_equal((NODE)->nodetype, NODETYPE); \
346 CHECK_POINTER((NODE)->parent, PARENT); \
347 CHECK_ARRAY((NODE)->typedefs, TYPEDEFS);
348
349/**
350 * @brief assert that lysp_action structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100351 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200352 * @param[in] NODE pointer to lysp_action variable
353 * @param[in] DSC expected description
354 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of extension list
355 * @param[in] FLAGS expected [schema node flags](@ref snodeflags)
356 * @param[in] GROUPINGS expected [sized array](@ref sizedarrays) size of grouping list
357 * @param[in] IFFEATURES expected [sized array](@ref sizedarrays) size of if-feature expressions list
358 * @param[in] INPUT_* ::LYSP_ACTION_INOUT_CHECK
359 * @param[in] NAME expected name
360 * @param[in] NODETYPE node type. LYS_RPC or LYS_ACTION
361 * @param[in] OUTPUT_* ::LYSP_ACTION_INOUT_CHECK
362 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
363 * @param[in] REF expected reference
364 * @param[in] TYPEDEFS expected [sized array](@ref sizedarrays) size of list of typedefs
365 */
366#define CHECK_LYSP_ACTION(NODE, DSC, EXTS, FLAGS, GROUPINGS, IFFEATURES, \
367 INPUT_DATA, INPUT_EXTS, INPUT_GROUPINGS, INPUT_MUSTS, \
368 INPUT_PARENT, INPUT_TYPEDEFS, \
369 NAME, NODETYPE, \
370 OUTPUT_DATA, OUTPUT_EXTS, OUTPUT_GROUPINGS, OUTPUT_MUSTS, \
371 OUTPUT_PARENT, OUTPUT_TYPEDEFS, \
372 PARENT, REF, TYPEDEFS) \
373 assert_non_null(NODE); \
374 CHECK_STRING((NODE)->dsc, DSC); \
375 CHECK_ARRAY((NODE)->exts, EXTS); \
376 assert_int_equal((NODE)->flags, FLAGS); \
Radek Krejci2a9fc652021-01-22 17:44:34 +0100377 CHECK_POINTER((NODE)->groupings, GROUPINGS); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200378 CHECK_ARRAY((NODE)->iffeatures, IFFEATURES); \
379 CHECK_LYSP_ACTION_INOUT(&((NODE)->input), INPUT_DATA, INPUT_EXTS, INPUT_GROUPINGS, \
380 INPUT_MUSTS, LYS_INPUT, INPUT_PARENT, INPUT_TYPEDEFS); \
381 assert_string_equal((NODE)->name, NAME); \
382 assert_int_equal((NODE)->nodetype, NODETYPE); \
383 CHECK_LYSP_ACTION_INOUT(&((NODE)->output), OUTPUT_DATA, OUTPUT_EXTS, OUTPUT_GROUPINGS, \
384 OUTPUT_MUSTS, LYS_OUTPUT, OUTPUT_PARENT, OUTPUT_TYPEDEFS); \
385 CHECK_POINTER((NODE)->parent, PARENT); \
386 CHECK_STRING((NODE)->ref, REF); \
387 CHECK_ARRAY((NODE)->typedefs, TYPEDEFS) \
388
389/**
390 * @brief assert that lysp_when structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100391 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200392 * @param[in] NODE pointer to lysp_when variable
393 * @param[in] COND expected string specifid condition
394 * @param[in] DSC expected string description statement
395 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of extension array
396 * @param[in] REF expected string reference
397 */
398#define CHECK_LYSP_WHEN(NODE, COND, DSC, EXTS, REF) \
399 assert_non_null(NODE); \
400 assert_string_equal((NODE)->cond, COND); \
401 CHECK_STRING((NODE)->dsc, DSC); \
402 CHECK_ARRAY((NODE)->exts, EXTS); \
403 if (REF == NULL) { \
404 assert_null((NODE)->ref); \
405 } else { \
406 assert_non_null((NODE)->ref); \
407 assert_string_equal((NODE)->ref, REF); \
408 }
409
410/**
411 * @brief assert that lysp_restr structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100412 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200413 * @param[in] NODE pointer to lysp_restr variable
414 * @param[in] ARG_STR expected string. The restriction expression/value
415 * @param[in] DSC expected descrition
416 * @param[in] EAPPTAG expected string reprezenting error-app-tag value
417 * @param[in] EMSG expected string reprezenting error message
418 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of extension array
419 * @param[in] REF expected reference
420 */
421
422#define CHECK_LYSP_RESTR(NODE, ARG_STR, DSC, EAPPTAG, EMSG, EXTS, REF) \
423 assert_non_null(NODE); \
424 assert_non_null((NODE)->arg.mod); \
425 assert_string_equal((NODE)->arg.str, ARG_STR); \
426 CHECK_STRING((NODE)->dsc, DSC); \
427 CHECK_STRING((NODE)->eapptag, EAPPTAG); \
428 CHECK_STRING((NODE)->emsg, EMSG); \
429 CHECK_ARRAY((NODE)->exts, EXTS); \
430 CHECK_STRING((NODE)->ref, REF);
431
432/**
433 * @brief assert that lysp_import structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100434 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200435 * @param[in] NODE pointer to lysp_import variable
436 * @param[in] DSC expected description or NULL
437 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of extensions
438 * @param[in] NAME expected name of imported module
439 * @param[in] PREFIX expected prefix for the data from the imported schema
440 * @param[in] REF expected reference
441 * @prame[in] REV expected reprezenting date in format "11-10-2020"
442 */
443#define CHECK_LYSP_IMPORT(NODE, DSC, EXTS, NAME, PREFIX, REF, REV) \
444 assert_non_null(NODE); \
445 CHECK_STRING((NODE)->dsc, DSC); \
446 CHECK_ARRAY((NODE)->exts, EXTS); \
447 /*assert_non_null((NODE)->module); // ?? it is mandatory but in some test it doesnt work */ \
448 assert_string_equal((NODE)->name, NAME); \
449 assert_string_equal((NODE)->prefix, PREFIX); \
450 CHECK_STRING((NODE)->ref, REF); \
451 CHECK_STRING((NODE)->rev, REV); \
452
453/**
454 * @brief assert that lysp_ext structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100455 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200456 * @param[in] NODE pointer to lysp_ext_instance variable
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100457 * @param[in] ARGNAME expected argument name
Radek Iša56ca9e42020-09-08 18:42:00 +0200458 * @param[in] COMPILED 0 -> compiled data dosnt exists, 1 -> compiled data exists
459 * @param[in] DSC expected string reprezent description
460 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of extension instances
461 * @param[in] FLAGS expected LYS_STATUS_* and LYS_YINELEM_* values (@ref snodeflags)
462 * @param[in] NAME expected name
463 * @param[in] REF expected ref
464 */
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100465#define CHECK_LYSP_EXT(NODE, ARGNAME, COMPILED, DSC, EXTS, FLAGS, NAME, REF) \
Radek Iša56ca9e42020-09-08 18:42:00 +0200466 assert_non_null(NODE); \
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100467 CHECK_STRING((NODE)->argname, ARGNAME); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200468 CHECK_POINTER((NODE)->compiled, COMPILED); \
469 CHECK_STRING((NODE)->dsc, DSC); \
470 CHECK_ARRAY((NODE)->exts, EXTS); \
471 assert_int_equal((NODE)->flags, FLAGS); \
472 assert_string_equal((NODE)->name, NAME); \
473 CHECK_STRING((NODE)->ref, REF);
474
475/**
476 * @brief assert that lysp_ext_instance structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100477 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200478 * @param[in] NODE pointer to lysp_ext_instance variable
479 * @param[in] ARGUMENT expected optional value of the extension's argument
480 * @param[in] CHILD 0 -> node doesnt have child, 1 -> node have children
Radek Krejciab430862021-03-02 20:13:40 +0100481 * @param[in] PARENT_STMT expected value identifying placement of the extension instance
482 * @param[in] PARENT_STMT_INDEX expected indentifi index
Michal Vaskofc2cd072021-02-24 13:17:17 +0100483 * @param[in] FORMAT expected format
Radek Iša56ca9e42020-09-08 18:42:00 +0200484 */
Radek Krejci85ac8312021-03-03 20:21:33 +0100485#define CHECK_LYSP_EXT_INSTANCE(NODE, ARGUMENT, CHILD, PARENT_STMT, PARENT_STMT_INDEX, NAME, FORMAT) \
Radek Iša56ca9e42020-09-08 18:42:00 +0200486 assert_non_null(NODE); \
487 CHECK_STRING((NODE)->argument, ARGUMENT); \
488 CHECK_POINTER((NODE)->child, CHILD); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200489 /*assert_int_equal((NODE)->flags, LYS_INTERNAL);*/ \
Radek Krejciab430862021-03-02 20:13:40 +0100490 assert_int_equal((NODE)->parent_stmt, PARENT_STMT); \
491 assert_int_equal((NODE)->parent_stmt_index, PARENT_STMT_INDEX); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200492 assert_string_equal((NODE)->name, NAME); \
Michal Vaskofc2cd072021-02-24 13:17:17 +0100493 assert_int_equal((NODE)->format, FORMAT);
Radek Iša56ca9e42020-09-08 18:42:00 +0200494
495/**
496 * @brief assert that lysp_stmt structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100497 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200498 * @param[in] NODE pointer to lysp_stmt variable
499 * @param[in] ARG expected statemet argumet
500 * @param[in] CHILD 0 -> node doesnt have child, 1 -> node have children
501 * @param[in] FLAGS expected statement flags, can be set to LYS_YIN_ATTR
502 * @param[in] KW expected numeric respresentation of the stmt value
503 * @param[in] NEXT 0 -> pointer is NULL, 1 -> pointer is not null
504 * @param[in] STMS expected identifier of the statement
505 */
506#define CHECK_LYSP_STMT(NODE, ARG, CHILD, FLAGS, KW, NEXT, STMT) \
507 assert_non_null(NODE); \
508 CHECK_STRING((NODE)->arg, ARG); \
509 CHECK_POINTER((NODE)->child, CHILD); \
510 assert_int_equal((NODE)->flags, FLAGS); \
511 assert_int_equal((NODE)->kw, KW); \
512 CHECK_POINTER((NODE)->next, NEXT); \
513 assert_string_equal((NODE)->stmt, STMT); \
514
515/**
516 * @brief assert that lysp_type_enum structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100517 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200518 * @param[in] NODE pointer to lysp_type_enum variable
519 * @param[in] DSC expected description
520 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
521 * @param[in] FLAGS only LYS_STATUS_ and LYS_SET_VALUE values are allowed
522 * @param[in] IFFEATURES expected [sized array](@ref sizedarrays) size of list of the extension instances
523 * @param[in] NAME expected name
524 * @param[in] REF expected reference statement
525 * @param[in] VALUE expected enum's value or bit's position
526 */
527#define CHECK_LYSP_TYPE_ENUM(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, REF, VALUE) \
528 assert_non_null(NODE); \
529 CHECK_STRING((NODE)->dsc, DSC); \
530 CHECK_ARRAY((NODE)->exts, EXTS); \
531 assert_int_equal((NODE)->flags, FLAGS); \
532 CHECK_ARRAY((NODE)->iffeatures, IFFEATURES); \
533 CHECK_STRING((NODE)->name, NAME); \
534 CHECK_STRING((NODE)->ref, REF); \
535 assert_int_equal(VALUE, (NODE)->value);
536
537/**
Radek Išaa9ff2b82021-01-13 21:44:13 +0100538 * @brief assert that lysp_type_enum structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100539 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100540 * @param[in] NODE pointer to lysp_type variable
541 * @param[in] BASES expected [sized array](@ref sizedarrays) size of list of indentifiers
542 * @param[in] BITS expected [sized array](@ref sizedarrays) size of list of bits
543 * @param[in] COMPILED 0 -> pointer to compiled type is null, 1 -> pointer to compilet type is valid
544 * @param[in] ENUMS expected [sized array](@ref sizedarrays) size of list of enums-stmts
545 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of extension instances
546 * @param[in] FLAGS expected flags
547 * @param[in] FRACTION_DIGITS expected number of fraction digits decimal64
548 * @param[in] LENGTH expected 0 -> there isnt any restriction on length, 1 -> type is restricted on length (string, binary)
549 * @param[in] NAME expected name of type
550 * @param[in] PATH 0 -> no pointer to parsed path, 1 -> pointer to parsed path is valid
551 * @param[in] PATTERNS expected [sized array](@ref sizedarrays) size of list of patterns for string
552 * @param[in] PMOD expected submodule where type is defined 0 -> pointer is null, 1 -> pointer is not null
553 * @param[in] RANGE expected [sized array](@ref sizedarrays) size of list of range restriction
554 * @param[in] REQUIRE_INSTANCE expected require instance flag
555 * @param[in] TYPES expected [sized array](@ref sizedarrays) size of list of sub-types
556 */
557#define CHECK_LYSP_TYPE(NODE, BASES, BITS, COMPILED, ENUMS, EXTS, FLAGS, FRACTIONS_DIGITS, \
558 LENGTH, NAME, PATH, PATTERNS, PMOD, RANGE, REQUIRE_INSTANCE, TYPES) \
559 assert_non_null(NODE);\
560 CHECK_ARRAY((NODE)->bases, BASES); \
561 CHECK_ARRAY((NODE)->bits, BITS); \
562 CHECK_POINTER((NODE)->compiled, COMPILED); \
563 CHECK_ARRAY((NODE)->enums, ENUMS); \
564 CHECK_ARRAY((NODE)->exts, EXTS); \
565 assert_int_equal((NODE)->flags, FLAGS); \
566 assert_int_equal((NODE)->fraction_digits, FRACTIONS_DIGITS); \
567 CHECK_POINTER((NODE)->length, LENGTH); \
568 CHECK_STRING((NODE)->name, NAME); \
569 CHECK_POINTER((NODE)->path, PATH); \
570 CHECK_ARRAY((NODE)->patterns, PATTERNS); \
571 CHECK_POINTER((NODE)->pmod, PMOD); \
572 CHECK_POINTER((NODE)->range, RANGE); \
573 assert_int_equal((NODE)->require_instance, REQUIRE_INSTANCE); \
574 CHECK_ARRAY((NODE)->types , TYPES)
575
576/**
Radek Iša56ca9e42020-09-08 18:42:00 +0200577 * @brief assert that lysp_node structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100578 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200579 * @param[in] NODE pointer to lysp_node variable
580 * @param[in] DSC expected description statement
581 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
582 * @param[in] FLAGS [schema node flags](@ref snodeflags)
583 * @param[in] IFFEATURES expected [sized array](@ref sizedarrays) size of list of the extension instances
584 * @param[in] NAME expected name
585 * @param[in] NEXT 0 pointer is null, 1 pointer is not null
586 * @param[in] NODETYPE node type LYS_UNKNOWN, LYS_CONTAINER, LYS_CHOICE, LYS_LEAF, LYS_LEAFLIST,
587 * LYS_LIST, LYS_ANYXML, LYS_ANYDATA, LYS_CASE, LYS_RPC, LYS_ACTION, LYS_NOTIF,
588 * LYS_USES, LYS_INPUT, LYS_OUTPUT, LYS_GROUPING, LYS_AUGMENT
589 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
590 * @param[in] REF expected reference statement
591 * @param[in] WHEN 0-> pointer is null, 1 -> pointer is not null
592 */
593#define CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, NODETYPE, PARENT, REF, WHEN) \
594 assert_non_null(NODE); \
595 CHECK_STRING((NODE)->dsc, DSC); \
596 CHECK_ARRAY((NODE)->exts, EXTS); \
597 assert_int_equal((NODE)->flags, FLAGS); \
598 CHECK_ARRAY((NODE)->iffeatures, IFFEATURES); \
599 CHECK_STRING((NODE)->name, NAME); \
600 CHECK_POINTER((NODE)->next, NEXT); \
601 assert_int_equal((NODE)->nodetype, NODETYPE); \
602 CHECK_POINTER((NODE)->parent, PARENT); \
603 CHECK_STRING((NODE)->ref, REF); \
Radek Krejci9a3823e2021-01-27 20:26:46 +0100604 CHECK_POINTER(lysp_node_when((struct lysp_node *)NODE), WHEN);
Radek Iša56ca9e42020-09-08 18:42:00 +0200605
606/**
Radek Išaa9ff2b82021-01-13 21:44:13 +0100607 * @brief assert that lysp_node structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100608 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100609 * @param[in] NODE pointer to lysp_node variable
610 * @param[in] DSC expected description statement
611 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
612 * @param[in] FLAGS [schema node flags](@ref snodeflags)
613 * @param[in] IFFEATURES expected [sized array](@ref sizedarrays) size of list of the extension instances
614 * @param[in] NAME expected name
615 * @param[in] NEXT 0 pointer is null, 1 pointer is not null
616 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
617 * @param[in] REF expected reference statement
618 * @param[in] WHEN 0-> pointer is null, 1 -> pointer is not null
619 * @param[in] MUSTS expected [sized array](@ref sizedarrays) size of list of must restriction
620 * @param[in] UNITS expected string reprezenting units
621 * @param[in] DFLT 0-> node dosn't have default value. 1 -> node have default value
622 */
623#define CHECK_LYSP_NODE_LEAF(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, \
624 PARENT, REF, WHEN, MUSTS, UNITS, DFLT) \
625 CHECK_LYSP_NODE(NODE, DSC, EXTS, FLAGS, IFFEATURES, NAME, NEXT, LYS_LEAF, PARENT, REF, WHEN); \
626 CHECK_ARRAY((NODE)->musts, MUSTS); \
627 CHECK_STRING((NODE)->units, UNITS); \
628 CHECK_STRING((NODE)->dflt.str, DFLT);
629
630/**
Radek Iša56ca9e42020-09-08 18:42:00 +0200631 * @brief assert that lysc_notif structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100632 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200633 * @param[in] NODE pointer to lysp_notif variable
634 * @param[in] DATA 0 pointer is null, 1 pointer is not null
635 * @param[in] DSC expected description
636 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
637 * @param[in] FLAGS [schema node flags](@ref snodeflags)
638 * @param[in] MODULE 0 pointer is null, 1 pointer is not null
639 * @param[in] MUSTS expected [sized array](@ref sizedarrays) size of list of must restriction
640 * @param[in] NAME expected name
641 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
642 * @param[in] PRIV 0-> pointer is null, 1-> pointer is not null
643 * @param[in] REF expected reference
644 * @param[in] WHEN expected [sized array](@ref sizedarrays) size of list of pointers to when statements
645 */
646#define CHECK_LYSC_NOTIF(NODE, DATA, DSC, EXTS, FLAGS, MODULE, MUSTS, NAME, PARENT, PRIV, REF, WHEN) \
647 assert_non_null(NODE); \
Radek Krejci01180ac2021-01-27 08:48:22 +0100648 CHECK_POINTER((NODE)->child, DATA); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200649 CHECK_STRING((NODE)->dsc, DSC); \
650 CHECK_ARRAY((NODE)->exts, EXTS); \
651 assert_int_equal((NODE)->flags, FLAGS); \
652 CHECK_POINTER((NODE)->module, MODULE); \
653 CHECK_ARRAY((NODE)->musts, MUSTS); \
654 assert_string_equal((NODE)->name, NAME); \
655 assert_int_equal((NODE)->nodetype, LYS_NOTIF); \
656 CHECK_POINTER((NODE)->parent, PARENT); \
657 CHECK_POINTER((NODE)->priv, PRIV); \
658 CHECK_STRING((NODE)->ref, REF); \
Radek Išaa9ff2b82021-01-13 21:44:13 +0100659 CHECK_ARRAY(lysc_node_when((const struct lysc_node *)NODE), WHEN);
Radek Iša56ca9e42020-09-08 18:42:00 +0200660
661/**
662 * @brief assert that lysc_action_inout structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100663 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200664 * @param[in] NODE pointer to lysp_notif variable
665 * @param[in] DATA 0 pointer is null, 1 pointer is not null
666 * @param[in] MUST expected [sized array](@ref sizedarrays) size of list of must restrictions
667 * @param[in] NODETYPE LYS_INPUT or LYS_OUTPUT
668 */
669#define CHECK_LYSC_ACTION_INOUT(NODE, DATA, MUST, NODETYPE) \
670 assert_non_null(NODE); \
Radek Krejci01180ac2021-01-27 08:48:22 +0100671 CHECK_POINTER((NODE)->child, DATA); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200672 CHECK_ARRAY((NODE)->musts, MUST); \
673 assert_int_equal((NODE)->nodetype, NODETYPE);
674
675/**
676 * @brief assert that lysc_action structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100677 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200678 * @param[in] NODE pointer to lysp_action variable
679 * @param[in] DSC string description statement
680 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
681 * @param[in] FLAGS [schema node flags](@ref snodeflags)
682 * @param[in] INPUT_DATA 0 pointer is null, 1 pointer is not null
683 * @param[in] INPUT_MUST expected [sized array](@ref sizedarrays) size of input list of must restrictions
684 * @param[in] INPUT_EXTS expected [sized array](@ref sizedarrays) size of the input extension instances of input
685 * @param[in] MODULE 0 pointer is null, 1 pointer is not null
686 * @param[in] NAME expected name
687 * @param[in] NODETYPE LYS_RPC, LYS_ACTION
688 * @param[in] OUTPUT_DATA 0 pointer is null, 1 pointer is not null
689 * @param[in] OUTPUT_MUST expected [sized array](@ref sizedarrays) size of output list of must restrictions
690 * @param[in] OUTPUT_EXTS expected [sized array](@ref sizedarrays) size of the output extension instances of input
691 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
692 * @param[in] PRIV 0-> pointer is null, 1-> pointer is not null
693 * @param[in] REF expected reference
694 * @param[in] WHEN expected [sized array](@ref sizedarrays) size of list of pointers to when statements
695 */
696#define CHECK_LYSC_ACTION(NODE, DSC, EXTS, FLAGS, INPUT_DATA, INPUT_MUST, INPUT_EXTS, MODULE, NAME, NODETYPE, \
697 OUTPUT_DATA, OUTPUT_MUST, OUTPUT_EXTS, PARENT, PRIV, REF, WHEN) \
698 assert_non_null(NODE); \
699 CHECK_STRING((NODE)->dsc, DSC); \
700 CHECK_ARRAY((NODE)->exts, EXTS); \
701 assert_int_equal((NODE)->flags, FLAGS); \
702 CHECK_LYSC_ACTION_INOUT(&(NODE)->input, INPUT_DATA, INPUT_MUST, LYS_INPUT); \
Radek Krejci2a9fc652021-01-22 17:44:34 +0100703 CHECK_ARRAY((NODE)->input.exts, INPUT_EXTS); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200704 CHECK_POINTER((NODE)->module, MODULE); \
705 assert_string_equal((NODE)->name, NAME); \
706 assert_int_equal((NODE)->nodetype, NODETYPE); \
707 CHECK_LYSC_ACTION_INOUT(&(NODE)->output, OUTPUT_DATA, OUTPUT_MUST, LYS_OUTPUT); \
Radek Krejci2a9fc652021-01-22 17:44:34 +0100708 CHECK_ARRAY((NODE)->output.exts, OUTPUT_EXTS); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200709 CHECK_POINTER((NODE)->parent, PARENT); \
710 CHECK_POINTER((NODE)->priv, PRIV); \
711 CHECK_STRING((NODE)->ref, REF); \
Radek Išaa9ff2b82021-01-13 21:44:13 +0100712 CHECK_ARRAY(lysc_node_when((const struct lysc_node *)NODE), WHEN);
Radek Iša56ca9e42020-09-08 18:42:00 +0200713
714/**
715 * @brief assert that lysc_node structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100716 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200717 * @param[in] NODE pointer to lysc_node variable
718 * @param[in] DSC expected description
719 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
720 * @param[in] FLAGS [schema node flags](@ref snodeflags)
721 * @param[in] MODULE 0 pointer is null, 1 pointer is not null
722 * @param[in] NAME expected name
723 * @param[in] NEXT 0 pointer is null, 1 pointer is not null
724 * @param[in] NODETYPE type of the node LYS_UNKNOWN, LYS_CONTAINER, LYS_CHOICE, LYS_LEAF,
725 * LYS_LEAFLIST, LYS_LIST, LYS_ANYXML, LYS_ANYDATA, LYS_CASE, LYS_RPC,
726 * LYS_ACTION, LYS_NOTIF, LYS_USES, LYS_INPUT, LYS_OUTPUT, LYS_GROUPING,
727 * LYS_AUGMENT
728 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
729 * @param[in] PRIV 0-> pointer is null, 1-> pointer is not null
730 * @param[in] REF expected reference
731 * @param[in] WHEN expected [sized array](@ref sizedarrays) size of list of pointers to when statements
732 */
733#define CHECK_LYSC_NODE(NODE, DSC, EXTS, FLAGS, MODULE, NAME, NEXT, NODETYPE, PARENT, PRIV, REF, WHEN) \
734 assert_non_null(NODE); \
735 CHECK_STRING((NODE)->dsc, DSC); \
736 CHECK_ARRAY((NODE)->exts, EXTS); \
737 assert_int_equal((NODE)->flags, FLAGS); \
738 CHECK_POINTER((NODE)->module, MODULE); \
739 assert_string_equal((NODE)->name, NAME); \
740 CHECK_POINTER((NODE)->next, NEXT); \
741 assert_int_equal((NODE)->nodetype, NODETYPE); \
742 CHECK_POINTER((NODE)->parent, PARENT); \
743 assert_non_null((NODE)->prev); \
744 CHECK_POINTER((NODE)->priv, PRIV); \
745 CHECK_STRING((NODE)->ref, REF); \
Radek Išaa9ff2b82021-01-13 21:44:13 +0100746 CHECK_ARRAY(lysc_node_when((const struct lysc_node *)NODE), WHEN);
747
748/**
749 * @brief assert that lysc_node_leaf structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100750 *
Radek Išaa9ff2b82021-01-13 21:44:13 +0100751 * @param[in] NODE pointer to lysc_node variable
752 * @param[in] DSC expected description
753 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
754 * @param[in] FLAGS [schema node flags](@ref snodeflags)
755 * @param[in] MODULE 0 pointer is null, 1 pointer is not null
756 * @param[in] NAME expected name
757 * @param[in] NEXT 0 pointer is null, 1 pointer is not null
758 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
759 * @param[in] PRIV 0-> pointer is null, 1-> pointer is not null
760 * @param[in] REF expected reference
Radek Išaa76902f2021-03-29 08:52:51 +0200761 * @param[in] ACTIONS 1 if is set pointer to structure lysc_node_action other 0
762 * @param[in] CHILD 1 if is set pointer to child other 0
763 * @param[in] MAX possible maximum elements in list
764 * @param[in] MIN possible minimum elements in list
765 * @param[in] MUSTS [sized array](@ref sizedarrays) number of must node elements in array
766 * @param[in] NOTIFS 1 if is set pointer to any notifs node
767 * @param[in] UNIQUES [sized array](@ref sizedarrays) number of unique nodes element in array
768 * @param[in] WHEN [sized array](@ref sizedarrays) size of when node array
769 */
770#define CHECK_LYSC_NODE_LIST(NODE, DSC, EXTS, FLAGS, MODULE, NAME, NEXT, \
771 PARENT, PRIV, REF, ACTIONS, CHILD, MAX, MIN, MUSTS, NOTIFS, UNIQUES, WHEN) \
772 CHECK_LYSC_NODE(NODE, DSC, EXTS, FLAGS, MODULE, NAME, NEXT, LYS_LIST, PARENT, PRIV, REF, WHEN); \
773 CHECK_POINTER((NODE)->actions, ACTIONS); \
774 CHECK_POINTER((NODE)->child, CHILD); \
775 assert_int_equal((NODE)->max, MAX); \
776 assert_int_equal((NODE)->min, MIN); \
777 CHECK_ARRAY((NODE)->musts, MUSTS); \
778 CHECK_POINTER((NODE)->notifs, NOTIFS); \
779 CHECK_ARRAY((NODE)->uniques, UNIQUES); \
780 CHECK_ARRAY(lysc_node_when((const struct lysc_node *)NODE), WHEN)
781
782/**
783 * @brief assert that lysc_node_leaf structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100784 *
Radek Išaa76902f2021-03-29 08:52:51 +0200785 * @param[in] NODE pointer to lysc_node variable
786 * @param[in] DSC expected description
787 * @param[in] EXTS expected [sized array](@ref sizedarrays) size of list of the extension instances
788 * @param[in] FLAGS [schema node flags](@ref snodeflags)
789 * @param[in] MODULE 0 pointer is null, 1 pointer is not null
790 * @param[in] NAME expected name
791 * @param[in] NEXT 0 pointer is null, 1 pointer is not null
792 * @param[in] PARENT 0-> check if node is root, 1-> check if node is not root
793 * @param[in] PRIV 0-> pointer is null, 1-> pointer is not null
794 * @param[in] REF expected reference
795 * @param[in] WHEN expected [sized array](@ref sizedarrays) size of list of pointers to when statements
Radek Išaa9ff2b82021-01-13 21:44:13 +0100796 * @param[in] MUSTS expected [sized array](@ref sizedarrays) size of list of must restriction
797 * @param[in] UNITS expected string reprezenting units
798 * @param[in] DFLT 0-> node dosn't have default value. 1 -> node have default value
799 */
800#define CHECK_LYSC_NODE_LEAF(NODE, DSC, EXTS, FLAGS, MODULE, NAME, NEXT, \
801 PARENT, PRIV, REF, WHEN, MUSTS, UNITS, DFLT) \
802 CHECK_LYSC_NODE(NODE, DSC, EXTS, FLAGS, MODULE, NAME, NEXT, LYS_LEAF, PARENT, PRIV, REF, WHEN); \
803 CHECK_ARRAY((NODE)->musts, MUSTS); \
804 assert_non_null((NODE)->type); \
805 CHECK_STRING((NODE)->units, UNITS); \
806 CHECK_POINTER((NODE)->dflt, DFLT);
Radek Iša56ca9e42020-09-08 18:42:00 +0200807
808/**
809 * @brief assert that lyd_meta structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100810 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200811 * @param[in] NODE pointer to lyd_meta variable
812 * @param[in] ANNOTATION 0 pointer is null, 1 pointer is not null
813 * @param[in] NAME expected name
814 * @param[in] NEXT 0 pointer is null, 1 pointer is not null
815 * @param[in] TYPE_VAL value type. EMPTY, UNION, BITS, INST, ENUM, INT8, INT16, UINT8, STRING, LEAFREF, DEC64, BINARY, BOOL, IDENT
816 * part of text reprezenting LY_DATA_TYPE.
817 * @param[in] ... ::CHECK_LYD_VALUE
818 */
819#define CHECK_LYD_META(NODE, ANNOTATION, NAME, NEXT, PARENT, TYPE_VAL, ...) \
820 assert_non_null(NODE); \
821 CHECK_POINTER((NODE)->annotation, ANNOTATION); \
822 assert_string_equal((NODE)->name, NAME); \
823 CHECK_POINTER((NODE)->next, NEXT); \
824 CHECK_POINTER((NODE)->parent, PARENT); \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200825 CHECK_LYD_VALUE((NODE)->value, TYPE_VAL, __VA_ARGS__);
Radek Iša56ca9e42020-09-08 18:42:00 +0200826
827/**
828 * @brief assert that lyd_node_term structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100829 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200830 * @param[in] NODE pointer to lyd_node_term variable
831 * @param[in] FLAGS expected [data node flags](@ref dnodeflags)
832 * @param[in] META 0 -> meta is not prezent, 1 -> meta is prezent
833 * @param[in] NEXT 0 -> next node is not prezent, 1 -> next node is prezent
834 * @param[in] TYPE_VAL value type. EMPTY, UNION, BITS, INST, ENUM, INT8, INT16, UINT8, STRING, LEAFREF, DEC64, BINARY, BOOL, IDENT
835 * part of text reprezenting LY_DATA_TYPE.
836 * @param[in] ... ::CHECK_LYD_VALUE
837 */
838#define CHECK_LYD_NODE_TERM(NODE, FLAGS, META, NEXT, PARENT, SCHEMA, VALUE_TYPE, ...) \
839 assert_non_null(NODE); \
840 assert_int_equal((NODE)->flags, FLAGS); \
841 CHECK_POINTER((NODE)->meta, META); \
842 CHECK_POINTER((NODE)->next, NEXT); \
843 CHECK_POINTER((NODE)->parent, PARENT); \
844 assert_non_null((NODE)->prev); \
845 CHECK_POINTER((NODE)->schema, SCHEMA); \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200846 CHECK_LYD_VALUE((NODE)->value, VALUE_TYPE, __VA_ARGS__);
Radek Iša56ca9e42020-09-08 18:42:00 +0200847
848/**
849 * @brief assert that lyd_node_any structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100850 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200851 * @param[in] NODE pointer to lyd_node_term variable
852 * @param[in] FLAGS expected [data node flags](@ref dnodeflags)
853 * @param[in] META 0 meta isnt present , 1 meta is present
854 * @param[in] PARENT 0 it is root node , 1 node have parent
855 * @param[in] VALUE_TYPE value type ::lyd_node_any.value
856 */
857#define CHECK_LYD_NODE_ANY(NODE, FLAGS, META, PARENT, VALUE_TYPE) \
858 assert_non_null(NODE); \
859 assert_int_equal((NODE)->flags, FLAGS); \
860 CHECK_POINTER((NODE)->meta, META); \
861 CHECK_POINTER((NODE)->meta, PARENT); \
862 assert_non_null((NODE)->prev); \
863 assert_non_null((NODE)->schema); \
864 assert_int_equal((NODE)->value_type, VALUE_TYPE);
865
866/**
867 * @brief assert that lyd_node_opaq structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100868 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200869 * @param[in] NODE pointer to lyd_node_opaq variable
870 * @param[in] ATTR 0 if pointer is null ,1 if pointer is not null
871 * @param[in] CHILD 0 if pointer is null ,1 if pointer is not null
872 * @param[in] FORMAT LY_PREF_XML or LY_PREF_JSON
873 * @param[in] VAL_PREFS 0 if pointer is null ,1 if pointer is not null
874 * @param[in] NAME expected name
875 * @param[in] value expected orignal value
876 */
877#define CHECK_LYD_NODE_OPAQ(NODE, ATTR, CHILD, FORMAT, NAME, NEXT, PARENT, PREFIX, VAL_PREFS, VALUE) \
878 assert_non_null(NODE); \
879 CHECK_POINTER((NODE)->attr, ATTR); \
880 CHECK_POINTER((NODE)->child, CHILD); \
881 assert_ptr_equal((NODE)->ctx, UTEST_LYCTX); \
882 assert_int_equal((NODE)->flags, 0); \
883 assert_true((NODE)->format == FORMAT); \
884 assert_int_equal((NODE)->hash, 0); \
885 assert_string_equal((NODE)->name.name, NAME); \
886 assert_non_null((NODE)->prev); \
887 assert_null((NODE)->schema); \
888 CHECK_POINTER((NODE)->val_prefix_data, VAL_PREFS); \
889 assert_string_equal((NODE)->value, VALUE);
890
891/**
Radek Išaa76902f2021-03-29 08:52:51 +0200892 * @brief assert that lyd_node_opaq structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100893 *
Radek Išaa76902f2021-03-29 08:52:51 +0200894 * @param[in] NODE pointer to lyd_node_opaq variable
895 * @param[in] CHILD 1 if node has children other 0
896 * @param[in] HILD_HT 1 if node has children hash table other 0
897 * @param[in] META 1 if node has metadata other 0
898 * @param[in] FLAGS expected flag
899 * @param[in] NEXT 1 if next node is present other 0
900 * @param[in] PARENT 1 if node has parent other 0
901 * @param[in] PRIV 1 if node has private data other 0
902 * @param[in] SCHEMA 1 if node has schema other 0
903*/
904#define CHECK_LYD_NODE_INNER(NODE, CHILD, CHILD_HT, META, FLAGS, NEXT, PARENT, PRIV, SCHEMA) \
905 assert_non_null(NODE); \
906 CHECK_POINTER((NODE)->child, CHILD); \
907 CHECK_POINTER((NODE)->children_ht, CHILD_HT); \
908 CHECK_POINTER((NODE)->meta, META); \
909 assert_int_equal((NODE)->flags, FLAGS); \
910 CHECK_POINTER((NODE)->parent, PARENT); \
911 assert_non_null((NODE)->prev); \
912 CHECK_POINTER((NODE)->next, NEXT); \
913 CHECK_POINTER((NODE)->priv, PRIV); \
914 CHECK_POINTER((NODE)->schema, SCHEMA)
915
916/**
Radek Iša56ca9e42020-09-08 18:42:00 +0200917 * @brief assert that lyd_value structure members are correct
Michal Vaskoddd76592022-01-17 13:34:48 +0100918 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200919 * @param[in] NODE lyd_value
920 * @param[in] TYPE_VAL value type. EMPTY, UNION, BITS, INST, ENUM, INT8, INT16, UINT8, STRING, LEAFREF, DEC64, BINARY, BOOL, IDENT
921 * part of text reprezenting LY_DATA_TYPE.
922 * @param[in] ... Unspecified parameters. Type and numbers of parameters are specified
923 * by type of value. These parameters are passed to macro
924 * CHECK_LYD_VALUE_ ## TYPE_VAL.
925 */
926#define CHECK_LYD_VALUE(NODE, TYPE_VAL, ...) \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200927 CHECK_LYD_VALUE_ ## TYPE_VAL (NODE, __VA_ARGS__);
Radek Iša56ca9e42020-09-08 18:42:00 +0200928
929/*
930 * LYD VALUES CHECKING SPECIALIZATION
931 */
932
933/**
934 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type EMPTY
935 * Example CHECK_LYD_VALUE(node->value, EMPTY, "");
Michal Vaskoddd76592022-01-17 13:34:48 +0100936 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200937 * @param[in] NODE lyd_value variable
938 * @param[in] CANNONICAL_VAL expected cannonical value
939 */
940#define CHECK_LYD_VALUE_EMPTY(NODE, CANNONICAL_VAL) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200941 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +0200942 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200943 assert_non_null((NODE).realtype); \
944 assert_int_equal((NODE).realtype->basetype, LY_TYPE_EMPTY);
945
946/**
947 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type UNION
948 * Example CHECK_LYD_VALUE(node->value, UNION, "12", INT8, "12", 12);
949 * @warning type of subvalue cannot be UNION. Example of calling
Michal Vaskoddd76592022-01-17 13:34:48 +0100950 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200951 * @param[in] NODE lyd_value variable
952 * @param[in] CANNONICAL_VAL expected cannonical value
953 * @param[in] TYPE_VAL value type. EMPTY, UNION, BITS, INST, ENUM, INT8, INT16, UINT8, STRING, LEAFREF, DEC64, BINARY, BOOL, IDENT
954 * @param[in] ... Unspecified parameters. Type and numbers of parameters are specified
955 * by type of value. These parameters are passed to macro
956 * CHECK_LYD_VALUE_ ## TYPE_VAL.
957 */
958#define CHECK_LYD_VALUE_UNION(NODE, CANNONICAL_VAL, TYPE_VAL, ...) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200959 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +0200960 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200961 assert_non_null((NODE).realtype); \
962 assert_int_equal(LY_TYPE_UNION, (NODE).realtype->basetype); \
963 assert_non_null((NODE).subvalue); \
964 assert_non_null((NODE).subvalue->prefix_data); \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200965 CHECK_LYD_VALUE_ ## TYPE_VAL ((NODE).subvalue->value, __VA_ARGS__)
966
967/**
968 * @brief Internal macro. Get 1st variadic argument.
969 */
970#define _GETARG1(ARG1, ...) ARG1
Radek Iša56ca9e42020-09-08 18:42:00 +0200971
972/**
973 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type BITS
974 * Example arr[] = {"a", "b"}; CHECK_LYD_VALUE(node->value, BITS, "a b", arr);
Michal Vaskoddd76592022-01-17 13:34:48 +0100975 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200976 * @param[in] NODE lyd_value variable
977 * @param[in] CANNONICAL_VAL expected cannonical value
978 * @param[in] VALUE expected array of bits names
979 */
Michal Vasko151ae6c2021-09-23 08:23:51 +0200980#define CHECK_LYD_VALUE_BITS(NODE, ...) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200981 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200982 assert_string_equal((NODE)._canonical, _GETARG1(__VA_ARGS__, DUMMY)); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200983 assert_non_null((NODE).realtype); \
984 assert_int_equal(LY_TYPE_BITS, (NODE).realtype->basetype); \
985 { \
Radek Išaded31052021-03-10 13:22:53 +0100986 const char *arr[] = { __VA_ARGS__ }; \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200987 LY_ARRAY_COUNT_TYPE arr_size = (sizeof(arr) / sizeof(arr[0])) - 1; \
Michal Vaskoaa0ee622021-05-11 09:29:25 +0200988 struct lyd_value_bits *_val; \
989 LYD_VALUE_GET(&(NODE), _val); \
990 assert_int_equal(arr_size, LY_ARRAY_COUNT(_val->items)); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200991 for (LY_ARRAY_COUNT_TYPE it = 0; it < arr_size; it++) { \
Michal Vasko151ae6c2021-09-23 08:23:51 +0200992 assert_string_equal(arr[it + 1], _val->items[it]->name); \
Radek Iša56ca9e42020-09-08 18:42:00 +0200993 } \
994 }
995
996/**
997 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type INST
Michal Vaskoddd76592022-01-17 13:34:48 +0100998 *
Radek Iša56ca9e42020-09-08 18:42:00 +0200999 * @param[in] NODE lyd_value variable
1000 * @param[in] CANNONICAL_VAL expected cannonical value
1001 * @param[in] VALUE expected array of enum ly_path_pred_type
1002 * @brief Example enum arr[] = {0x0, 0x1}; CHECK_LYD_VALUE(node->value, INST, "test/d", arr);
1003 */
1004#define CHECK_LYD_VALUE_INST(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001005 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001006 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001007 assert_non_null((NODE).realtype); \
1008 assert_int_equal(LY_TYPE_INST, (NODE).realtype->basetype); \
1009 { \
Michal Vasko79135ae2020-12-16 10:08:35 +01001010 LY_ARRAY_COUNT_TYPE arr_size = sizeof(VALUE) / sizeof(VALUE[0]); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001011 assert_int_equal(arr_size, LY_ARRAY_COUNT((NODE).target)); \
1012 for (LY_ARRAY_COUNT_TYPE it = 0; it < arr_size; it++) { \
1013 assert_int_equal(VALUE[it], (NODE).target[it].pred_type); \
1014 } \
1015 }
1016
1017/**
1018 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type ENUM.
1019 * Example CHECK_LYD_VALUE(node->value, ENUM, "item_name", "item_name");
Michal Vaskoddd76592022-01-17 13:34:48 +01001020 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001021 * @param[in] NODE lyd_value variable
1022 * @param[in] CANNONICAL_VAL expected cannonical value
1023 * @param[in] VALUE expected enum item name
1024 */
1025#define CHECK_LYD_VALUE_ENUM(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001026 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001027 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001028 assert_non_null((NODE).realtype); \
1029 assert_int_equal(LY_TYPE_ENUM, (NODE).realtype->basetype); \
1030 assert_string_equal(VALUE, (NODE).enum_item->name);
1031
1032/**
1033 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type INT8
1034 * Example CHECK_LYD_VALUE(node->value, INT8, "12", 12);
Michal Vaskoddd76592022-01-17 13:34:48 +01001035 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001036 * @param[in] NODE lyd_value variable
1037 * @param[in] CANNONICAL_VAL expected cannonical value
1038 * @param[in] VALUE expected inteager value (-128 to 127).
1039 */
1040#define CHECK_LYD_VALUE_INT8(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001041 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001042 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001043 assert_non_null((NODE).realtype); \
1044 assert_int_equal(LY_TYPE_INT8, (NODE).realtype->basetype); \
1045 assert_int_equal(VALUE, (NODE).int8);
1046
1047/**
1048 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type INT16
1049 * Example CHECK_LYD_VALUE(node->value, INT8, "12", 12);
Michal Vaskoddd76592022-01-17 13:34:48 +01001050 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001051 * @param[in] NODE lyd_value variable
1052 * @param[in] CANNONICAL_VAL expected cannonical value
1053 * @param[in] VALUE expected inteager value.
1054 */
1055#define CHECK_LYD_VALUE_INT16(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001056 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001057 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001058 assert_non_null((NODE).realtype); \
1059 assert_int_equal(LY_TYPE_INT16, (NODE).realtype->basetype); \
1060 assert_int_equal(VALUE, (NODE).int16);
1061
1062/**
1063 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type UINT8.
1064 * Example CHECK_LYD_VALUE(node->value, UINT8, "12", 12);
Michal Vaskoddd76592022-01-17 13:34:48 +01001065 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001066 * @param[in] NODE lyd_value variable
1067 * @param[in] CANNONICAL_VAL expected cannonical value
1068 * @param[in] VALUE expected inteager (0 to 255).
1069 */
1070#define CHECK_LYD_VALUE_UINT8(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001071 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001072 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001073 assert_non_null((NODE).realtype); \
1074 assert_int_equal(LY_TYPE_UINT8, (NODE).realtype->basetype); \
1075 assert_int_equal(VALUE, (NODE).uint8);
1076
1077/**
Radek Išaa76902f2021-03-29 08:52:51 +02001078 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type UINT32.
1079 * Example CHECK_LYD_VALUE(node->value, UINT32, "12", 12);
Michal Vaskoddd76592022-01-17 13:34:48 +01001080 *
Radek Išaa76902f2021-03-29 08:52:51 +02001081 * @param[in] NODE lyd_value variable
1082 * @param[in] CANNONICAL_VAL expected cannonical value
1083 * @param[in] VALUE expected inteager (0 to MAX_UINT32).
1084 */
1085#define CHECK_LYD_VALUE_UINT32(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001086 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001087 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Išaa76902f2021-03-29 08:52:51 +02001088 assert_non_null((NODE).realtype); \
1089 assert_int_equal(LY_TYPE_UINT32, (NODE).realtype->basetype); \
1090 assert_int_equal(VALUE, (NODE).uint32);
1091
1092/**
Radek Iša56ca9e42020-09-08 18:42:00 +02001093 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type STRING.
1094 * Example CHECK_LYD_VALUE(node->value, STRING, "text");
Michal Vaskoddd76592022-01-17 13:34:48 +01001095 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001096 * @param[in] NODE lyd_value variable
1097 * @param[in] CANNONICAL_VAL expected cannonical value
1098 */
1099#define CHECK_LYD_VALUE_STRING(NODE, CANNONICAL_VAL) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001100 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001101 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001102 assert_non_null((NODE).realtype); \
1103 assert_int_equal(LY_TYPE_STRING, (NODE).realtype->basetype);
1104
1105/**
1106 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type LEAFREF
Michal Vaskoddd76592022-01-17 13:34:48 +01001107 * Example CHECK_LYD_VALUE(node->value, LEAFREF, "");
1108 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001109 * @param[in] NODE lyd_value variable
1110 * @param[in] CANNONICAL_VAL expected cannonical value
1111 */
1112#define CHECK_LYD_VALUE_LEAFREF(NODE, CANNONICAL_VAL) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001113 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001114 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001115 assert_non_null((NODE).realtype); \
1116 assert_int_equal(LY_TYPE_LEAFREF, (NODE).realtype->basetype); \
1117 assert_non_null((NODE).ptr)
1118
1119/**
1120 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type DEC64
1121 * Example CHECK_LYD_VALUE(node->value, DEC64, "125", 125);
Michal Vaskoddd76592022-01-17 13:34:48 +01001122 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001123 * @param[in] NODE lyd_value variable
1124 * @param[in] CANNONICAL_VAL expected cannonical value
1125 * @param[in] VALUE expected value 64bit inteager
1126*/
1127#define CHECK_LYD_VALUE_DEC64(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001128 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001129 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001130 assert_non_null((NODE).realtype); \
1131 assert_int_equal(LY_TYPE_DEC64, (NODE).realtype->basetype); \
1132 assert_int_equal(VALUE, (NODE).dec64);
1133
1134/**
1135 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type BINARY.
1136 * Example CHECK_LYD_VALUE(node->value, BINARY, "aGVs\nbG8=");
Michal Vaskoddd76592022-01-17 13:34:48 +01001137 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001138 * @param[in] NODE lyd_value variable
1139 * @param[in] CANNONICAL_VAL expected cannonical value
Michal Vasko495f4502021-04-27 14:48:05 +02001140 * @param[in] VALUE expected value data
1141 * @param[in] SIZE expected value data size
Radek Iša56ca9e42020-09-08 18:42:00 +02001142*/
Michal Vasko495f4502021-04-27 14:48:05 +02001143#define CHECK_LYD_VALUE_BINARY(NODE, CANNONICAL_VAL, VALUE, SIZE) \
Michal Vaskoaa0ee622021-05-11 09:29:25 +02001144 { \
1145 struct lyd_value_binary *_val; \
1146 LYD_VALUE_GET(&(NODE), _val); \
1147 assert_int_equal(_val->size, SIZE); \
1148 assert_int_equal(0, memcmp(_val->data, VALUE, SIZE)); \
1149 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
1150 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
1151 assert_non_null((NODE).realtype); \
1152 assert_int_equal(LY_TYPE_BINARY, (NODE).realtype->basetype); \
1153 }
Radek Iša56ca9e42020-09-08 18:42:00 +02001154
1155/**
1156 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type BOOL.
1157 * Example CHECK_LYD_VALUE(node->value, BOOL, "true", 1);
Michal Vaskoddd76592022-01-17 13:34:48 +01001158 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001159 * @param[in] NODE lyd_value variable
1160 * @param[in] CANNONICAL_VAL expected cannonical value
1161 * @param[in] VALUE expected boolean value 0,1
1162*/
1163#define CHECK_LYD_VALUE_BOOL(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001164 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001165 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001166 assert_non_null((NODE).realtype); \
1167 assert_int_equal(LY_TYPE_BOOL, (NODE).realtype->basetype); \
1168 assert_int_equal(VALUE, (NODE).boolean);
1169
1170/**
1171 * @brief Internal macro. Assert that lyd_value structure members are correct. Lyd value is type IDENT.
1172 * Example CHECK_LYD_VALUE(node->value, IDENT, "types:gigabit-ethernet", "gigabit-ethernet");
Michal Vaskoddd76592022-01-17 13:34:48 +01001173 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001174 * @param[in] NODE lyd_value variable
1175 * @param[in] CANNONICAL_VAL expected cannonical value
1176 * @param[in] VALUE expected ident name
1177*/
1178#define CHECK_LYD_VALUE_IDENT(NODE, CANNONICAL_VAL, VALUE) \
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001179 assert_non_null((NODE).realtype->plugin->print(UTEST_LYCTX, &(NODE), LY_VALUE_CANON, NULL, NULL, NULL)); \
Radek Krejci995784f2021-04-26 08:02:13 +02001180 assert_string_equal((NODE)._canonical, CANNONICAL_VAL); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001181 assert_non_null((NODE).realtype); \
1182 assert_int_equal(LY_TYPE_IDENT, (NODE).realtype->basetype); \
1183 assert_string_equal(VALUE, (NODE).ident->name);
1184
1185/**
Radek Išaa9ff2b82021-01-13 21:44:13 +01001186 * @brief Macro testing parser when parsing incorrect module;
Michal Vaskoddd76592022-01-17 13:34:48 +01001187 *
Radek Išaa9ff2b82021-01-13 21:44:13 +01001188 * @param[in] DATA String storing the schema module representation.
1189 * @param[in] FORMAT Schema format of the @p DATA
1190 * @param[in] FEATURES Array of module's features to enable
1191 * @param[in] RET_VAL ly_in_new_memory return error value
1192 */
1193#define UTEST_INVALID_MODULE(DATA, FORMAT, FEATURES, RET_VAL) \
1194 { \
Michal Vasko4de7d072021-07-09 09:13:18 +02001195 struct lys_module *mod; \
Radek Išaa9ff2b82021-01-13 21:44:13 +01001196 assert_int_equal(LY_SUCCESS, ly_in_new_memory(DATA, &_UC->in)); \
1197 assert_int_equal(RET_VAL, lys_parse(_UC->ctx, _UC->in, FORMAT, FEATURES, &mod)); \
1198 assert_null(mod); \
1199 } \
1200 ly_in_free(_UC->in, 0); \
1201 _UC->in = NULL; \
1202
1203/**
Radek Iša56ca9e42020-09-08 18:42:00 +02001204 * @brief Add module (from a string) into the used libyang context.
Michal Vaskoddd76592022-01-17 13:34:48 +01001205 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001206 * @param[in] DATA String storing the schema module representation.
1207 * @param[in] FORMAT Schema format of the @p DATA
1208 * @param[in] FEATURES Array of module's features to enable
1209 * @param[out] MOD Optional parameter as a pointer to variable to store the resulting module.
1210 */
1211#define UTEST_ADD_MODULE(DATA, FORMAT, FEATURES, MOD) \
1212 assert_int_equal(LY_SUCCESS, ly_in_new_memory(DATA, &_UC->in)); \
1213 assert_int_equal(LY_SUCCESS, lys_parse(_UC->ctx, _UC->in, FORMAT, FEATURES, MOD)); \
1214 ly_in_free(_UC->in, 0); \
1215 _UC->in = NULL
1216
1217/**
1218 * @brief Internal macro to compare error info record with the expected error message and path.
1219 * If NULL is provided as MSG, no error info record (NULL) is expected.
Michal Vaskoddd76592022-01-17 13:34:48 +01001220 *
Radek Iša56ca9e42020-09-08 18:42:00 +02001221 * @param[in] ERR Error information record from libyang context.
1222 * @param[in] MSG Expected error message.
1223 * @param[in] PATH Expected error path.
1224 *
1225 */
1226#define _CHECK_LOG_CTX(ERR, MSG, PATH) \
1227 if (!MSG) { \
1228 assert_null(ERR); \
1229 } else { \
1230 assert_non_null(ERR); \
1231 CHECK_STRING((ERR)->msg, MSG); \
1232 CHECK_STRING((ERR)->path, PATH); \
1233 }
1234
1235/**`
1236 * @brief Internal macro to check the last libyang's context error.
1237 */
1238#define _CHECK_LOG_CTX1(MSG, PATH) \
1239 _CHECK_LOG_CTX(ly_err_last(_UC->ctx), MSG, PATH)
1240
1241/**
1242 * @brief Internal macro to check the last two libyang's context error.
1243 */
1244#define _CHECK_LOG_CTX2(MSG1, PATH1, MSG2, PATH2) \
1245 _CHECK_LOG_CTX(ly_err_last(_UC->ctx), MSG1, PATH1); \
1246 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev, MSG2, PATH2)
1247
1248/**
1249 * @brief Internal macro to check the last three libyang's context error.
1250 */
1251#define _CHECK_LOG_CTX3(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3) \
1252 _CHECK_LOG_CTX2(MSG1, PATH1, MSG2, PATH2); \
1253 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev->prev, MSG3, PATH3)
1254
1255/**
Radek Krejcife6ec262021-01-20 10:28:28 +01001256 * @brief Internal macro to check the last three libyang's context error.
1257 */
1258#define _CHECK_LOG_CTX4(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4) \
1259 _CHECK_LOG_CTX3(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3); \
1260 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev->prev->prev, MSG4, PATH4)
1261
1262/**
1263 * @brief Internal macro to check the last three libyang's context error.
1264 */
1265#define _CHECK_LOG_CTX5(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5) \
1266 _CHECK_LOG_CTX4(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4); \
1267 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev->prev->prev->prev, MSG5, PATH5)
1268
1269/**
Radek Krejci8297b792020-08-16 14:49:05 +02001270 * @brief Internal macro to check the last three libyang's context error.
1271 */
1272#define _CHECK_LOG_CTX6(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5, MSG6, PATH6) \
1273 _CHECK_LOG_CTX5(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5); \
1274 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev->prev->prev->prev->prev, MSG6, PATH6)
1275
1276/**
1277 * @brief Internal macro to check the last three libyang's context error.
1278 */
1279#define _CHECK_LOG_CTX7(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5, MSG6, PATH6, MSG7, PATH7) \
1280 _CHECK_LOG_CTX6(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5, MSG6, PATH6); \
1281 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev->prev->prev->prev->prev->prev, MSG7, PATH7)
1282
1283/**
1284 * @brief Internal macro to check the last three libyang's context error.
1285 */
1286#define _CHECK_LOG_CTX8(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5, MSG6, PATH6, MSG7, PATH7, MSG8, PATH8) \
1287 _CHECK_LOG_CTX7(MSG1, PATH1, MSG2, PATH2, MSG3, PATH3, MSG4, PATH4, MSG5, PATH5, MSG6, PATH6, MSG7, PATH7); \
1288 _CHECK_LOG_CTX(ly_err_last(_UC->ctx)->prev->prev->prev->prev->prev->prev->prev, MSG8, PATH8)
1289
1290/**
Radek Iša56ca9e42020-09-08 18:42:00 +02001291 * @brief Internal helper macro to select _CHECK_LOG_CTX* macro according to the provided parameters.
1292 */
Radek Krejci8297b792020-08-16 14:49:05 +02001293#define _GET_CHECK_LOG_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, NAME, ...) NAME
Radek Iša56ca9e42020-09-08 18:42:00 +02001294
1295/**
1296 * @brief Check expected error(s) in libyang context.
1297 *
1298 * Macro has variadic parameters expected to be provided in pairs of error message and error path starting
1299 * from the latest error. Current limit is checking at most 3 last errors. After checking, macro cleans up
1300 * all the errors from the libyang context.
1301 *
1302 * @param[in] MSG Expected error message.
1303 * @param[in] PATH Expected error path.
1304 */
1305#define CHECK_LOG_CTX(...) \
Radek Krejci8297b792020-08-16 14:49:05 +02001306 _GET_CHECK_LOG_MACRO(__VA_ARGS__, _CHECK_LOG_CTX8, _INVAL, _CHECK_LOG_CTX7, _INVAL, \
1307 _CHECK_LOG_CTX6, _INVAL, _CHECK_LOG_CTX5, _INVAL, _CHECK_LOG_CTX4, _INVAL, \
Michal Vasko151ae6c2021-09-23 08:23:51 +02001308 _CHECK_LOG_CTX3, _INVAL, _CHECK_LOG_CTX2, _INVAL, _CHECK_LOG_CTX1, DUMMY)(__VA_ARGS__); \
Radek Iša56ca9e42020-09-08 18:42:00 +02001309 ly_err_clean(_UC->ctx, NULL)
1310
1311/**
Michal Vaskoe9391c72021-10-05 10:04:56 +02001312 * @brief Check expected error in libyang context including error-app-tag.
1313 *
1314 * @param[in] MSG Expected error message.
1315 * @param[in] PATH Expected error path.
1316 * @param[in] APPTAG Expected error-app-tag.
1317 */
1318#define CHECK_LOG_CTX_APPTAG(MSG, PATH, APPTAG) \
1319 if (!MSG) { \
1320 assert_null(ly_err_last(_UC->ctx)); \
1321 } else { \
1322 assert_non_null(ly_err_last(_UC->ctx)); \
1323 CHECK_STRING(ly_err_last(_UC->ctx)->msg, MSG); \
1324 CHECK_STRING(ly_err_last(_UC->ctx)->path, PATH); \
1325 CHECK_STRING(ly_err_last(_UC->ctx)->apptag, APPTAG); \
1326 } \
1327 ly_err_clean(_UC->ctx, NULL)
1328
1329/**
Radek Iša56ca9e42020-09-08 18:42:00 +02001330 * @brief Clean up the logging callback's storage.
1331 */
1332#define UTEST_LOG_CLEAN \
1333 free(_UC->err_msg); \
1334 free(_UC->err_path); \
1335 _UC->err_msg = NULL; \
1336 _UC->err_path = NULL;
1337
1338/**
1339 * @brief Check expected error directly logged via logging callback.
1340 * Useful mainly for messages logged by functions without access to libyang context.
1341 * @param[in] MSG Expected error message.
1342 * @param[in] PATH Expected error path.
1343 */
1344#define CHECK_LOG(MSG, PATH) \
1345 CHECK_STRING(_UC->err_msg, MSG); \
1346 CHECK_STRING(_UC->err_path, PATH); \
1347 UTEST_LOG_CLEAN
1348
1349#ifdef _UTEST_MAIN_
1350/*
1351 * Functions inlined into each C source file including this header with _UTEST_MAIN_ defined
1352 */
1353
1354/**
1355 * @brief Global variable holding the tests context to simplify access to it.
1356 */
1357struct utest_context *current_utest_context;
1358
1359/* set to 0 to printing error messages to stderr instead of checking them in code */
1360#define ENABLE_LOGGER_CHECKING 1
1361
1362/**
1363 * @brief Logging callback for libyang.
1364 */
1365static void
1366_utest_logger(LY_LOG_LEVEL level, const char *msg, const char *path)
1367{
1368 (void) level; /* unused */
1369
1370 if (ENABLE_LOGGER_CHECKING == 0) {
Radek Išaa9ff2b82021-01-13 21:44:13 +01001371 printf("\tERROR:\n\t\tMESSAGE: %s\n\t\tPATH: %s\n\t\tLEVEL: %i\n", msg, path, level);
Radek Iša56ca9e42020-09-08 18:42:00 +02001372 } else {
1373 free(current_utest_context->err_msg);
1374 current_utest_context->err_msg = msg ? strdup(msg) : NULL;
1375 free(current_utest_context->err_path);
1376 current_utest_context->err_path = path ? strdup(path) : NULL;
1377 }
1378}
1379
1380/**
1381 * @brief Generic utest's setup
1382 */
1383static int
1384utest_setup(void **state)
1385{
Michal Vasko86421632021-05-04 13:11:25 +02001386 char *cur_tz;
1387
Radek Iša56ca9e42020-09-08 18:42:00 +02001388 /* setup the logger */
1389 ly_set_log_clb(_utest_logger, 1);
1390 ly_log_options(LY_LOLOG | LY_LOSTORE);
1391
1392 current_utest_context = calloc(1, sizeof *current_utest_context);
1393 assert_non_null(current_utest_context);
1394 *state = current_utest_context;
1395
1396 /* libyang context */
1397 assert_int_equal(LY_SUCCESS, ly_ctx_new(NULL, 0, &current_utest_context->ctx));
1398
Radek Krejci968d7552021-03-26 20:33:51 +01001399 /* clean all errors from the setup - usually warnings regarding the plugins directories */
1400 UTEST_LOG_CLEAN;
1401
Michal Vasko86421632021-05-04 13:11:25 +02001402 /* backup timezone, if any */
1403 cur_tz = getenv("TZ");
1404 if (cur_tz) {
1405 current_utest_context->orig_tz = strdup(cur_tz);
1406 }
1407
1408 /* set CET */
1409 setenv("TZ", "CET+02:00", 1);
1410
Radek Iša56ca9e42020-09-08 18:42:00 +02001411 return 0;
1412}
1413
1414/**
1415 * @brief macro to include generic utest's setup into the test-specific setup.
1416 *
1417 * Place at the beginning of the test-specific setup
1418 */
1419#define UTEST_SETUP \
1420 assert_int_equal(0, utest_setup(state))
1421
1422/**
1423 * @brief Generic utest's teardown
1424 */
1425static int
1426utest_teardown(void **state)
1427{
1428 *state = NULL;
1429
1430 /* libyang context */
Radek Krejci90ed21e2021-04-12 14:47:46 +02001431 ly_ctx_destroy(current_utest_context->ctx);
Radek Iša56ca9e42020-09-08 18:42:00 +02001432
Michal Vasko86421632021-05-04 13:11:25 +02001433 if (current_utest_context->orig_tz) {
1434 /* restore TZ */
1435 setenv("TZ", current_utest_context->orig_tz, 1);
1436 }
1437
Radek Iša56ca9e42020-09-08 18:42:00 +02001438 /* utest context */
1439 ly_in_free(current_utest_context->in, 0);
1440 free(current_utest_context->err_msg);
1441 free(current_utest_context->err_path);
Michal Vasko86421632021-05-04 13:11:25 +02001442 free(current_utest_context->orig_tz);
Radek Iša56ca9e42020-09-08 18:42:00 +02001443 free(current_utest_context);
1444 current_utest_context = NULL;
1445
1446 return 0;
1447}
1448
1449/**
1450 * @brief macro to include generic utest's teardown into the test-specific teardown.
1451 *
1452 * Place at the end of the test-specific teardown
1453 */
1454#define UTEST_TEARDOWN \
1455 assert_int_equal(0, utest_teardown(state))
1456
1457/**
1458 * @brief Internal macro for utest setup with test-specific setup and teardown
1459 */
1460#define _UTEST_SETUP_TEARDOWN(FUNC, SETUP, TEARDOWN) \
1461 cmocka_unit_test_setup_teardown(FUNC, SETUP, TEARDOWN)
1462
1463/**
1464 * @brief Internal macro for utest setup with test-specific setup and generic teardown
1465 */
1466#define _UTEST_SETUP(FUNC, SETUP) \
1467 cmocka_unit_test_setup_teardown(FUNC, SETUP, utest_teardown)
1468
1469/**
1470 * @brief Internal macro for utest setup with generic setup and teardown
1471 */
1472#define _UTEST(FUNC) \
1473 cmocka_unit_test_setup_teardown(FUNC, utest_setup, utest_teardown)
1474
1475/**
1476 * @brief Internal helper macro to select _UTEST* macro according to the provided parameters.
1477 */
1478#define _GET_UTEST_MACRO(_1, _2, _3, NAME, ...) NAME
1479
1480/**
1481 * @brief Macro to specify test function using utest environment. Macro has variadic parameters
1482 * to provide test-specific setup/teardown functions:
1483 *
1484 * UTEST(test_func) - only implicit setup and teardown functions are used
1485 * UTEST(test_func, setup) - implicit teardown but own setup
1486 * UTEST(test_func, setup, teardown) - both setup and teardown are test-specific
1487 */
1488#define UTEST(...) \
Michal Vasko151ae6c2021-09-23 08:23:51 +02001489 _GET_UTEST_MACRO(__VA_ARGS__, _UTEST_SETUP_TEARDOWN, _UTEST_SETUP, _UTEST, DUMMY)(__VA_ARGS__)
Radek Iša56ca9e42020-09-08 18:42:00 +02001490
1491#else /* _UTEST_MAIN_ */
1492
1493extern struct utest_context *current_utest_context;
1494
1495#endif /* _UTEST_MAIN_ */
1496
1497#endif /* _UTESTS_H_ */