2 test_cases_get_all_nodes_by_dev_class.c.c -- Execution of specific meshlink black box test cases
3 Copyright (C) 2019 Guus Sliepen <guus@meshlink.io>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include "execute_tests.h"
25 #include "test_cases_get_all_nodes_by_dev_class.h"
26 #include "../common/containers.h"
27 #include "../common/test_step.h"
28 #include "../common/common_handlers.h"
36 /* Modify this to change the logging level of Meshlink */
37 #define TEST_MESHLINK_LOG_LEVEL MESHLINK_DEBUG
39 static void test_case_mesh_get_node_by_dev_class_01(void **state);
40 static bool test_steps_mesh_get_node_by_dev_class_01(void);
41 static void test_case_mesh_get_node_by_dev_class_02(void **state);
42 static bool test_steps_mesh_get_node_by_dev_class_02(void);
43 static void test_case_mesh_get_node_dev_class_01(void **state);
44 static bool test_steps_mesh_get_node_dev_class_01(void);
45 static void test_case_mesh_get_node_dev_class_02(void **state);
46 static bool test_steps_mesh_get_node_dev_class_02(void);
48 /* State structure for meshlink_get_node Test Case #1 */
49 static black_box_state_t test_mesh_get_node_by_dev_class_01_state = {
50 .test_case_name = "test_case_mesh_get_node_by_dev_class_01",
53 /* State structure for meshlink_get_node Test Case #2 */
54 static black_box_state_t test_mesh_get_node_by_dev_class_02_state = {
55 .test_case_name = "test_case_mesh_get_node_by_dev_class_02",
58 /* State structure for meshlink_get_node Test Case #3 */
59 static black_box_state_t test_mesh_get_node_01_state = {
60 .test_case_name = "test_mesh_get_node_01_state",
63 /* State structure for meshlink_get_node Test Case #4 */
64 static black_box_state_t test_mesh_get_node_02_state = {
65 .test_case_name = "test_mesh_get_node_02_state",
68 static void log_message(meshlink_handle_t *mesh, meshlink_log_level_t level, const char *text) {
71 static const char *levelstr[] = {
72 [MESHLINK_DEBUG] = "\x1b[34mDEBUG",
73 [MESHLINK_INFO] = "\x1b[32mINFO",
74 [MESHLINK_WARNING] = "\x1b[33mWARNING",
75 [MESHLINK_ERROR] = "\x1b[31mERROR",
76 [MESHLINK_CRITICAL] = "\x1b[31mCRITICAL",
79 fprintf(stderr, "%s(%s):\x1b[0m %s\n", mesh->name, levelstr[level], text);
82 /* Execute meshlink_get_node Test Case # 1 */
83 static void test_case_mesh_get_node_by_dev_class_01(void **state) {
84 execute_test(test_steps_mesh_get_node_by_dev_class_01, state);
87 /* Test Steps for meshlink_get_node Test Case # 1
90 1. Open nut, peer1, relay1, relay2, relay3 node instances, export and
91 import the configuration of NUT with other nodes.
92 2. Run the node instances.
93 3. Call meshlink_get_all_nodes_by_dev_class API with NULL as nodes array parameter
94 for DEV_CLASS_STATIONARY
95 4. Call meshlink_get_all_nodes_by_dev_class API with previously allocated nodes array
96 parameter for DEV_CLASS_BACKBONE
97 5. Call meshlink_get_all_nodes_by_dev_class API with previously allocated nodes array
98 parameter for DEV_CLASS_PORTABLE
101 meshlink_get_all_nodes_by_dev_class API should return appropriate node array pointer and
102 node member parameter when called and return accordingly.
104 static bool test_steps_mesh_get_node_by_dev_class_01(void) {
105 meshlink_node_t **nodes;
106 size_t nnodes = 0, i;
108 /* Create meshlink instance for NUT */
109 meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
111 meshlink_set_log_cb(mesh_nut, TEST_MESHLINK_LOG_LEVEL, log_message);
113 /* Create meshlink instance for peer1 */
114 meshlink_handle_t *mesh_peer1 = meshlink_open("getnodeconf.2", "peer1", "node_sim", DEV_CLASS_STATIONARY);
116 meshlink_set_log_cb(mesh_peer1, TEST_MESHLINK_LOG_LEVEL, log_message);
118 /* Create meshlink instance for relay1 */
119 meshlink_handle_t *mesh_relay1 = meshlink_open("getnodeconf.3", "relay1", "node_sim", DEV_CLASS_BACKBONE);
121 meshlink_set_log_cb(mesh_relay1, TEST_MESHLINK_LOG_LEVEL, log_message);
123 /* Create meshlink instance for relay2 */
124 meshlink_handle_t *mesh_relay2 = meshlink_open("getnodeconf.4", "relay2", "node_sim", DEV_CLASS_BACKBONE);
126 meshlink_set_log_cb(mesh_relay2, TEST_MESHLINK_LOG_LEVEL, log_message);
128 /* Create meshlink instance for relay3 */
129 meshlink_handle_t *mesh_relay3 = meshlink_open("getnodeconf.5", "relay3", "node_sim", DEV_CLASS_BACKBONE);
131 meshlink_set_log_cb(mesh_relay3, TEST_MESHLINK_LOG_LEVEL, log_message);
133 /* importing and exporting mesh meta data */
134 char *exp_nut = meshlink_export(mesh_nut);
135 assert(exp_nut != NULL);
136 char *export = meshlink_export(mesh_peer1);
137 assert(export != NULL);
138 assert(meshlink_import(mesh_nut, export));
139 assert(meshlink_import(mesh_peer1, exp_nut));
142 export = meshlink_export(mesh_relay1);
143 assert(export != NULL);
144 assert(meshlink_import(mesh_nut, export));
145 assert(meshlink_import(mesh_relay1, exp_nut));
148 export = meshlink_export(mesh_relay2);
149 assert(export != NULL);
150 assert(meshlink_import(mesh_nut, export));
151 assert(meshlink_import(mesh_relay2, exp_nut));
154 export = meshlink_export(mesh_relay3);
155 assert(export != NULL);
156 assert(meshlink_import(mesh_nut, export));
157 assert(meshlink_import(mesh_relay3, exp_nut));
161 nodes = meshlink_get_all_nodes_by_dev_class(mesh_nut, DEV_CLASS_STATIONARY, NULL, &nnodes);
162 assert_int_not_equal(nodes, NULL);
163 assert_int_equal(nnodes, 2);
165 for(i = 0; i < nnodes; i++) {
166 if(strcasecmp(nodes[i]->name, "nut") && strcasecmp(nodes[i]->name, "peer1")) {
171 nodes = meshlink_get_all_nodes_by_dev_class(mesh_nut, DEV_CLASS_BACKBONE, nodes, &nnodes);
172 assert_int_not_equal(nodes, NULL);
173 assert_int_equal(nnodes, 3);
175 for(i = 0; i < nnodes; i++) {
176 if(strcasecmp(nodes[i]->name, "relay1") && strcasecmp(nodes[i]->name, "relay2") && strcasecmp(nodes[i]->name, "relay3")) {
181 nodes = meshlink_get_all_nodes_by_dev_class(mesh_nut, DEV_CLASS_PORTABLE, nodes, &nnodes);
182 assert_int_equal(nodes, NULL);
183 assert_int_equal(nnodes, 0);
184 assert_int_equal(meshlink_errno, 0);
187 meshlink_close(mesh_nut);
188 meshlink_close(mesh_peer1);
189 meshlink_close(mesh_relay1);
190 meshlink_close(mesh_relay2);
191 meshlink_close(mesh_relay3);
196 /* Execute meshlink_get_node Test Case # 2 - Invalid case
197 Passing invalid parameters as input arguments */
198 static void test_case_mesh_get_node_by_dev_class_02(void **state) {
199 execute_test(test_steps_mesh_get_node_by_dev_class_02, state);
202 /* Test Steps for meshlink_get_node Test Case # 2
206 2. Call meshlink_get_all_nodes_by_dev_class API with invalid parameters
209 meshlink_get_all_nodes_by_dev_class API should return NULL and set appropriate
212 static bool test_steps_mesh_get_node_by_dev_class_02(void) {
213 meshlink_node_t **nodes;
216 assert(meshlink_destroy("getnodeconf.1"));
218 /* Create meshlink instance for NUT */
219 meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
221 meshlink_set_log_cb(mesh_nut, TEST_MESHLINK_LOG_LEVEL, log_message);
223 nodes = meshlink_get_all_nodes_by_dev_class(mesh_nut, DEV_CLASS_COUNT + 10, NULL, &nnodes);
224 assert_int_equal(nodes, NULL);
225 assert_int_not_equal(meshlink_errno, 0);
227 nodes = meshlink_get_all_nodes_by_dev_class(mesh_nut, DEV_CLASS_STATIONARY, NULL, NULL);
228 assert_int_equal(nodes, NULL);
229 assert_int_not_equal(meshlink_errno, 0);
231 nodes = meshlink_get_all_nodes_by_dev_class(NULL, DEV_CLASS_STATIONARY, NULL, &nnodes);
232 assert_int_equal(nodes, NULL);
233 assert_int_not_equal(meshlink_errno, 0);
235 meshlink_close(mesh_nut);
236 assert(meshlink_destroy("getnodeconf.1"));
240 /* Execute meshlink_get_node_dev_class Test Case # 1 */
241 static void test_case_mesh_get_node_dev_class_01(void **state) {
242 execute_test(test_steps_mesh_get_node_dev_class_01, state);
245 /* Test Steps for meshlink_get_node_dev_class Test Case # 1
248 1. Create NUT node with DEV_CLASS_STATIONARY device class and obtain node handle
249 2. Call meshlink_get_node_dev_class API
252 meshlink_get_node_dev_class API should return DEV_CLASS_STATIONARY device class
254 static bool test_steps_mesh_get_node_dev_class_01(void) {
255 assert(meshlink_destroy("getnodeconf.1"));
257 /* Create meshlink instance for NUT */
258 meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
260 meshlink_set_log_cb(mesh_nut, TEST_MESHLINK_LOG_LEVEL, log_message);
262 meshlink_node_t *node;
263 node = meshlink_get_self(mesh_nut);
266 dev_class_t dev_class = meshlink_get_node_dev_class(mesh_nut, node);
267 assert_int_equal(dev_class, DEV_CLASS_STATIONARY);
269 meshlink_close(mesh_nut);
270 assert(meshlink_destroy("getnodeconf.1"));
274 /* Execute meshlink_get_node_dev_class Test Case # 2 */
275 static void test_case_mesh_get_node_dev_class_02(void **state) {
276 execute_test(test_steps_mesh_get_node_dev_class_02, state);
279 /* Test Steps for meshlink_get_node_dev_class Test Case # 2
282 1. Create NUT and obtain NUT node handle
283 2. Call meshlink_get_node_dev_class API with invalid parameters
286 meshlink_get_node_dev_class API should return NULL and set appropriate
289 static bool test_steps_mesh_get_node_dev_class_02(void) {
290 assert(meshlink_destroy("getnodeconf.1"));
292 /* Create meshlink instance for NUT */
293 meshlink_handle_t *mesh_nut = meshlink_open("getnodeconf.1", "nut", "node_sim", DEV_CLASS_STATIONARY);
295 meshlink_set_log_cb(mesh_nut, TEST_MESHLINK_LOG_LEVEL, log_message);
297 meshlink_node_t *node;
298 node = meshlink_get_self(mesh_nut);
301 int dev_class = meshlink_get_node_dev_class(NULL, node);
302 assert_int_equal(dev_class, -1);
303 assert_int_not_equal(meshlink_errno, 0);
305 dev_class = meshlink_get_node_dev_class(mesh_nut, NULL);
306 assert_int_equal(dev_class, -1);
307 assert_int_not_equal(meshlink_errno, 0);
309 meshlink_close(mesh_nut);
310 assert(meshlink_destroy("getnodeconf.1"));
314 static int black_box_setup_test_case(void **state) {
317 fprintf(stderr, "Destroying confbases\n");
318 assert(meshlink_destroy("getnodeconf.1"));
319 assert(meshlink_destroy("getnodeconf.2"));
320 assert(meshlink_destroy("getnodeconf.3"));
321 assert(meshlink_destroy("getnodeconf.4"));
322 assert(meshlink_destroy("getnodeconf.5"));
323 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
324 meshlink_errno = MESHLINK_OK;
329 int test_meshlink_get_all_node_by_device_class(void) {
330 const struct CMUnitTest blackbox_get_node_tests[] = {
331 cmocka_unit_test_prestate_setup_teardown(test_case_mesh_get_node_by_dev_class_01, black_box_setup_test_case, black_box_setup_test_case,
332 (void *)&test_mesh_get_node_by_dev_class_01_state),
333 cmocka_unit_test_prestate_setup_teardown(test_case_mesh_get_node_by_dev_class_02, NULL, NULL,
334 (void *)&test_mesh_get_node_by_dev_class_02_state),
335 cmocka_unit_test_prestate_setup_teardown(test_case_mesh_get_node_dev_class_01, NULL, NULL,
336 (void *)&test_mesh_get_node_01_state),
337 cmocka_unit_test_prestate_setup_teardown(test_case_mesh_get_node_dev_class_02, NULL, NULL,
338 (void *)&test_mesh_get_node_02_state),
341 total_tests += sizeof(blackbox_get_node_tests) / sizeof(blackbox_get_node_tests[0]);
343 return cmocka_run_group_tests(blackbox_get_node_tests, NULL, NULL);