]> git.meshlink.io Git - meshlink/blob - test/blackbox/run_blackbox_tests/test_cases_sign.c
Fix compiler warnings in the test suites.
[meshlink] / test / blackbox / run_blackbox_tests / test_cases_sign.c
1 /*
2     test_cases_sign.c -- Execution of specific meshlink black box test cases
3     Copyright (C) 2018  Guus Sliepen <guus@meshlink.io>
4
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.
9
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.
14
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.
18 */
19
20 #include "execute_tests.h"
21 #include "test_cases_sign.h"
22 #include "../common/containers.h"
23 #include "../common/test_step.h"
24 #include "../common/common_handlers.h"
25 #include <assert.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <setjmp.h>
30 #include <cmocka.h>
31
32 /* Modify this to change the logging level of Meshlink */
33 #define TEST_MESHLINK_LOG_LEVEL MESHLINK_DEBUG
34
35 static void test_case_sign_01(void **state);
36 static bool test_sign_01(void);
37 static void test_case_sign_02(void **state);
38 static bool test_sign_02(void);
39 static void test_case_sign_03(void **state);
40 static bool test_sign_03(void);
41 static void test_case_sign_04(void **state);
42 static bool test_sign_04(void);
43 static void test_case_sign_05(void **state);
44 static bool test_sign_05(void);
45 static void test_case_sign_06(void **state);
46 static bool test_sign_06(void);
47 static void test_case_sign_07(void **state);
48 static bool test_sign_07(void);
49
50 /* State structure for sign API Test Case #1 */
51 static black_box_state_t test_case_sign_01_state = {
52         .test_case_name = "test_case_sign_01",
53 };
54
55 /* State structure for sign API Test Case #2 */
56 static black_box_state_t test_case_sign_02_state = {
57         .test_case_name = "test_case_sign_02",
58 };
59
60 /* State structure for sign API Test Case #3 */
61 static black_box_state_t test_case_sign_03_state = {
62         .test_case_name = "test_case_sign_03",
63 };
64
65 /* State structure for sign API Test Case #4 */
66 static black_box_state_t test_case_sign_04_state = {
67         .test_case_name = "test_case_sign_04",
68 };
69
70 /* State structure for sign API Test Case #5 */
71 static black_box_state_t test_case_sign_05_state = {
72         .test_case_name = "test_case_sign_05",
73 };
74
75 /* State structure for sign API Test Case #6 */
76 static black_box_state_t test_case_sign_06_state = {
77         .test_case_name = "test_case_sign_06",
78 };
79
80 /* State structure for sign API Test Case #7 */
81 static black_box_state_t test_case_sign_07_state = {
82         .test_case_name = "test_case_sign_07",
83 };
84
85
86 /* Execute sign_data Test Case # 1 - Valid case - sign a data successfully*/
87 static void test_case_sign_01(void **state) {
88         execute_test(test_sign_01, state);
89 }
90
91 /* Test Steps for meshlink_sign Test Case # 1 - Valid case
92
93     Test Steps:
94     1. Run NUT(Node Under Test)
95     2. Sign data
96
97     Expected Result:
98     Signs data successfully
99 */
100 static bool test_sign_01(void) {
101         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
102
103         // Create meshlink instance
104         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
105         assert(mesh_handle);
106         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
107         assert(meshlink_start(mesh_handle));
108
109         // Signing data
110
111         char *data = "Test";
112         char sig[MESHLINK_SIGLEN];
113         size_t ssize = MESHLINK_SIGLEN;
114         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
115
116         // Clean up
117         meshlink_close(mesh_handle);
118         meshlink_destroy("signconf");
119
120         return ret;
121 }
122
123 /* Execute sign_data Test Case # 2 - Invalid case - meshlink_sign passing NULL as mesh handle argument*/
124 static void test_case_sign_02(void **state) {
125         execute_test(test_sign_02, state);
126         return;
127 }
128
129 /* Test Steps for meshlink_sign Test Case # 2 - invalid case
130
131     Test Steps:
132     1. meshlink_sign API called by passing NULL as mesh handle argument
133
134     Expected Result:
135     API returns false hinting the error.
136 */
137 static bool test_sign_02(void) {
138         char *data = "Test";
139         char sig[MESHLINK_SIGLEN];
140         size_t ssize = MESHLINK_SIGLEN;
141
142         // Calling meshlink_sign API
143         bool ret = meshlink_sign(NULL, data, strlen(data) + 1, sig, &ssize);
144
145         if(!ret) {
146                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as mesh_handle arg\n");
147                 return true;
148         }
149
150         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as mesh_handle arg\n");
151         return false;
152 }
153
154 /* Execute sign_data Test Case # 3 - Invalid case - meshlink_sign passing data to be signed as NULL */
155 static void test_case_sign_03(void **state) {
156         execute_test(test_sign_03, state);
157 }
158
159 /* Test Steps for meshlink_sign Test Case # 3 - invalid case
160
161     Test Steps:
162     1. Run NUT(Node Under Test)
163     2. meshlink_sign API called by passing NULL as data argument
164         that has to be signed.
165
166     Expected Result:
167     API returns false hinting the error.
168 */
169 static bool test_sign_03(void) {
170         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
171
172         // Create meshlink instance
173         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
174         assert(mesh_handle);
175         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
176         assert(meshlink_start(mesh_handle));
177
178         // Signing Data
179         char *data = "Test";
180         char sig[MESHLINK_SIGLEN];
181         size_t ssize = MESHLINK_SIGLEN;
182         bool ret = meshlink_sign(mesh_handle, NULL, strlen(data) + 1, sig, &ssize);
183
184         // Clean up
185
186         meshlink_close(mesh_handle);
187         meshlink_destroy("signconf");
188
189         if(!ret) {
190                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as data arg\n");
191                 return true;
192         } else {
193                 PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as data arg\n");
194                 return false;
195         }
196 }
197
198 /* Execute sign_data Test Case # 4 - Invalid case - meshlink_sign passing 0 as size of data
199       to be signed */
200 static void test_case_sign_04(void **state) {
201         execute_test(test_sign_04, state);
202 }
203
204 /* Test Steps for meshlink_sign Test Case # 3 - invalid case
205
206     Test Steps:
207     1. Run NUT(Node Under Test)
208     2. meshlink_sign API called by passing 0 as size of data to be signed
209
210     Expected Result:
211     API returns false hinting the error.
212 */
213 static bool test_sign_04(void) {
214         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
215
216         // Create meshlink instance
217
218         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
219         assert(mesh_handle);
220         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
221         assert(meshlink_start(mesh_handle));
222
223         // Signing data
224
225         char *data = "Test";
226         char sig[MESHLINK_SIGLEN];
227         size_t ssize = MESHLINK_SIGLEN;
228         bool ret = meshlink_sign(mesh_handle, data, 0, sig, &ssize);
229
230         // Clean up
231
232         meshlink_close(mesh_handle);
233         meshlink_destroy("signconf");
234
235         if(!ret) {
236                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing 0 as size of data arg\n");
237                 return true;
238         }
239
240         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing 0 as size of data arg\n");
241         return false;
242 }
243
244 /* Execute sign_data Test Case # 5 - Invalid case - meshlink_sign passing NULL as
245       signature buffer argument*/
246 static void test_case_sign_05(void **state) {
247         execute_test(test_sign_05, state);
248 }
249
250 /* Test Steps for meshlink_sign Test Case # 5 - invalid case
251
252     Test Steps:
253     1. Run NUT(Node Under Test)
254     2. meshlink_sign API called by passing NULL for signature buffer argument
255
256     Expected Result:
257     API returns false hinting the error.
258 */
259 static bool test_sign_05(void) {
260         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
261
262         // Create meshlink instance
263
264         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
265         assert(mesh_handle);
266         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
267         assert(meshlink_start(mesh_handle));
268
269         // Signing data
270
271         char *data = "Test";
272         size_t ssize = MESHLINK_SIGLEN;
273         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, NULL, &ssize);
274
275         // Clean up
276
277         meshlink_close(mesh_handle);
278         meshlink_destroy("signconf");
279
280         if(!ret) {
281                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as sign arg\n");
282                 return true;
283         }
284
285         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as sign arg\n");
286         return false;
287 }
288
289 /* Execute sign_data Test Case # 6 - Invalid case - meshlink_sign passing NULL for size of
290       signature argument */
291 static void test_case_sign_06(void **state) {
292         execute_test(test_sign_06, state);
293 }
294
295 /* Test Steps for meshlink_sign Test Case # 6 - invalid case
296
297     Test Steps:
298     1. Run NUT(Node Under Test)
299     2. meshlink_sign API called by passing NULL for size of signature buffer argument
300
301     Expected Result:
302     API returns false hinting the error.
303 */
304 static bool test_sign_06(void) {
305         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
306
307         // Create meshlink instance
308         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
309         assert(mesh_handle);
310         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
311         assert(meshlink_start(mesh_handle));
312
313         // Signing data
314
315         char *data = "Test";
316         char sig[MESHLINK_SIGLEN];
317         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, NULL);
318
319         // Clean up
320
321         meshlink_close(mesh_handle);
322         meshlink_destroy("signconf");
323
324         if(!ret) {
325                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as signsize arg\n");
326                 return true;
327         }
328
329         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as signsize arg\n");
330         return false;
331 }
332
333 /* Execute sign_data Test Case # 7 - Invalid case - meshlink_sign passing size of signature < MESHLINK_SIGLEN*/
334 static void test_case_sign_07(void **state) {
335         execute_test(test_sign_07, state);
336 }
337
338 /* Test Steps for meshlink_sign Test Case # 6 - invalid case
339
340     Test Steps:
341     1. Run NUT(Node Under Test)
342     2. meshlink_sign API called by passing size of signature < MESHLINK_SIGLEN
343
344     Expected Result:
345     API returns false hinting the error.
346 */
347 static bool test_sign_07(void) {
348         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
349
350         // Create meshlink instance
351
352         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
353         assert(mesh_handle);
354         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
355         assert(meshlink_start(mesh_handle));
356
357         // Signing data
358
359         char *data = "Test";
360         char sig[MESHLINK_SIGLEN];
361         size_t ssize = 5;  //5 < MESHLINK_SIGLEN
362         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
363
364         // Cleanup
365
366         meshlink_stop(mesh_handle);
367         meshlink_close(mesh_handle);
368         meshlink_destroy("signconf");
369
370         if(!ret) {
371                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing signsize < MESHLINK_SIGLEN arg\n");
372                 return true;
373         }
374
375         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing signsize < MESHLINK_SIGLEN arg\n");
376         return false;
377 }
378
379
380 int test_meshlink_sign(void) {
381         const struct CMUnitTest blackbox_sign_tests[] = {
382                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_01, NULL, NULL,
383                                 (void *)&test_case_sign_01_state),
384                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_02, NULL, NULL,
385                                 (void *)&test_case_sign_02_state),
386                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_03, NULL, NULL,
387                                 (void *)&test_case_sign_03_state),
388                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_04, NULL, NULL,
389                                 (void *)&test_case_sign_04_state),
390                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_05, NULL, NULL,
391                                 (void *)&test_case_sign_05_state),
392                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_06, NULL, NULL,
393                                 (void *)&test_case_sign_06_state),
394                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_07, NULL, NULL,
395                                 (void *)&test_case_sign_07_state)
396         };
397         total_tests += sizeof(blackbox_sign_tests) / sizeof(blackbox_sign_tests[0]);
398
399         return cmocka_run_group_tests(blackbox_sign_tests, NULL, NULL);
400 }