1 : /*
2 : * This file is part of MIN Test Framework. Copyright © 2008 Nokia Corporation
3 : * and/or its subsidiary(-ies).
4 : * Contact: Marko Hyyppä
5 : * Contact e-mail: DG.MIN-Support@nokia.com
6 : *
7 : * This program is free software: you can redistribute it and/or modify it
8 : * under the terms of the GNU General Public License as published by the Free
9 : * Software Foundation, version 2 of the License.
10 : *
11 : * This program is distributed in the hope that it will be useful, but WITHOUT
12 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 : * more details. You should have received a copy of the GNU General Public
15 : * License along with this program. If not, see
16 : * <http://www.gnu.org/licenses/>.
17 : */
18 :
19 :
20 : /**
21 : * @file check_dsa.tests
22 : * @version 0.1
23 : * @brief This file contains implementation of DSA unit test codes
24 : */
25 :
26 :
27 : /* ------------------------------------------------------------------------- */
28 : /* INCLUDE FILES */
29 : #include <stdlib.h>
30 : #include <assert.h>
31 : #include <check.h>
32 :
33 : #include "../../engine/data_structures_api/data_api.h"
34 :
35 : /* ------------------------------------------------------------------------- */
36 : /* EXTERNAL DATA STRUCTURES */
37 : /* None */
38 :
39 : /* ------------------------------------------------------------------------- */
40 : /* EXTERNAL FUNCTION PROTOTYPES */
41 : /* None */
42 :
43 : /* ------------------------------------------------------------------------- */
44 : /* CONSTANTS */
45 : /* None */
46 :
47 : /* ------------------------------------------------------------------------- */
48 : /* MACROS */
49 : /* None */
50 :
51 : /* ------------------------------------------------------------------------- */
52 : /* LOCAL CONSTANTS AND MACROS */
53 : /* None */
54 :
55 : /* ------------------------------------------------------------------------- */
56 : /* MODULE DATA STRUCTURES */
57 : /* None */
58 :
59 : /* ------------------------------------------------------------------------- */
60 : /* LOCAL FUNCTION PROTOTYPES */
61 : /* None */
62 :
63 : /* ------------------------------------------------------------------------- */
64 : /* FORWARD DECLARATIONS */
65 : /* None */
66 :
67 : /* ==================== LOCAL FUNCTIONS ==================================== */
68 : /* None */
69 :
70 : /* ======================== FUNCTIONS ====================================== */
71 : /* None */
72 :
73 : /* ------------------------------------------------------------------------- */
74 :
75 : /* ------------------------------------------------------------------------- */
76 :
77 : /* ------------------------------------------------------------------------- */
78 :
79 :
80 : /* ================= OTHER EXPORTED FUNCTIONS ============================== */
81 : /* None */
82 :
83 :
84 : /* ================= TESTS FOR LOCAL FUNCTIONS ============================= */
85 :
86 1 : START_TEST(test_module_info_add_to_list)
87 : {
88 1 : DLList* dllist = INITPTR;
89 : DLListIterator dllist_item;
90 : test_module_info_s* tm_data;
91 : char TOO_LONG_FILENAME[MaxFileName + 30];
92 : int i;
93 1 : char ch = 65; /* ASCII charachter 'A' */
94 :
95 542 : for (i=0; i<(MaxFileName + 29); i++) {
96 541 : TOO_LONG_FILENAME[i] = ch;
97 541 : ch++;
98 541 : if (ch > 90) ch = 65;
99 : }
100 :
101 1 : TOO_LONG_FILENAME[MaxFileName + 30] = '\0';
102 :
103 1 : tm_data = tm_create(TOO_LONG_FILENAME, INITPTR,0);
104 1 : fail_unless(tm_data == INITPTR,
105 : "failed to check too long filename string");
106 :
107 1 : dllist = dl_list_create();
108 1 : fail_unless (dllist != INITPTR, "failed to create linked list");
109 1 : tm_data = tm_create("test_module1.dat", INITPTR,0);
110 1 : fail_unless (tm_data != INITPTR,
111 : "failed to create Test Module Info data item");
112 :
113 1 : dllist_item = tm_add(dllist, tm_data);
114 1 : fail_unless (dllist_item != INITPTR,
115 : "failed to add Test Module Info data item");
116 : }
117 1 : END_TEST
118 :
119 : /* ------------------------------------------------------------------------- */
120 :
121 1 : START_TEST(test_module_info_set_pid)
122 : {
123 1 : const long TEST_PID = 100;
124 1 : DLList* dllist = INITPTR;
125 : DLListIterator dllist_item;
126 : test_module_info_s* tm_data;
127 : long retvalue;
128 :
129 1 : dllist = dl_list_create();
130 1 : fail_unless (dllist != INITPTR, "failed to create list");
131 :
132 1 : tm_data = tm_create("test_module1.dat", INITPTR,0);
133 1 : fail_unless (tm_data != INITPTR,
134 : "failed to create Test Module Info data item");
135 :
136 1 : dllist_item = tm_add(dllist, tm_data);
137 1 : fail_unless (dllist_item != INITPTR,
138 : "failed to add Test Module Info data item");
139 :
140 1 : tm_set_pid(dllist_item, TEST_PID);
141 1 : retvalue=tm_get_pid(dllist_item);
142 1 : fail_unless (retvalue == TEST_PID, "failed to add/get data item");
143 : }
144 1 : END_TEST
145 :
146 : /* ------------------------------------------------------------------------- */
147 :
148 1 : START_TEST(test_module_info_remove_from_list)
149 : {
150 1 : DLList* tm_list = INITPTR;
151 : DLListIterator tm_data_item[5];
152 : test_module_info_s* test_module[5];
153 1 : const int CHECK_ID = 3;
154 1 : DLListIterator check_item = INITPTR;
155 1 : BOOL data_found = FALSE;
156 : int result;
157 : int i;
158 :
159 1 : tm_list = dl_list_create();
160 1 : fail_unless (tm_list != INITPTR, "failed to create list");
161 :
162 6 : for (i=0; i<5; i++) {
163 5 : test_module[i] = tm_create("test_module.dat", INITPTR,0);
164 5 : fail_unless(test_module[i] != INITPTR,
165 : "failed to create Test Module Info data item");
166 :
167 5 : tm_data_item[i] = tm_add(tm_list, test_module[i]);
168 5 : fail_unless(tm_data_item[i] != INITPTR,
169 : "failed to add Test Module Info data item to list");
170 : }
171 :
172 1 : tm_remove(tm_data_item[CHECK_ID]);
173 :
174 1 : check_item = dl_list_head(tm_list);
175 1 : i = 0;
176 1 : data_found = FALSE;
177 :
178 6 : while (check_item != INITPTR) {
179 4 : if (check_item->data_ == tm_data_item[CHECK_ID])
180 0 : data_found = TRUE;
181 4 : check_item = dl_list_next(check_item);
182 4 : i++;
183 : }
184 :
185 1 : fail_unless((i == 4 && data_found == FALSE),
186 : "failed to remove Test Case data item from list");
187 : }
188 1 : END_TEST
189 :
190 : /* ------------------------------------------------------------------------- */
191 :
192 1 : START_TEST(test_module_info_delete_data)
193 : {
194 1 : DLList* tm_list = INITPTR;
195 1 : test_module_info_s* test_module = INITPTR;
196 1 : DLListIterator tm_data_item = INITPTR;
197 1 : DLList* cfg_filename_list = INITPTR;
198 1 : filename_t *FILENAME = INITPTR;
199 1 : title_string_t TITLE = "TITLE EXAMPLE";
200 1 : DLList* tc_list = INITPTR;
201 : test_case_s* test_case[10];
202 : DLListIterator tc_data_item[10];
203 1 : int result = 0;
204 : int i;
205 :
206 1 : tm_list = dl_list_create();
207 1 : fail_unless(tm_list != INITPTR, "failed to create list");
208 :
209 1 : cfg_filename_list = dl_list_create();
210 1 : fail_unless(cfg_filename_list != INITPTR, "failed to create list");
211 :
212 11 : for (i=0; i<10; i++) {
213 10 : FILENAME = NEW2(char, strlen("FILENAME.CFG")+1);
214 10 : STRCPY(FILENAME,"FILENAME.CFG",13);
215 10 : result = dl_list_add(cfg_filename_list, FILENAME);
216 10 : fail_unless(result != -1,
217 : "failed to add config filename string to list");
218 : }
219 :
220 1 : test_module = tm_create("test_module.dat", cfg_filename_list,0);
221 1 : fail_unless(test_module != INITPTR,
222 : "failed to create Test Module Info data item");
223 :
224 1 : tm_data_item = tm_add(tm_list, test_module);
225 1 : fail_unless(tm_data_item != INITPTR,
226 : "failed to create Test Module Info data item");
227 :
228 1 : tc_list = dl_list_create();
229 1 : fail_unless(tc_list != INITPTR, "failed to create list");
230 :
231 11 : for (i=0; i<10; i++) {
232 10 : test_case[i] = tc_create(INITPTR, FILENAME, TITLE);
233 10 : fail_unless(test_case[i] != INITPTR,
234 : "failed to create Test Case data structure");
235 :
236 10 : tc_data_item[i] = tc_add(tc_list, test_case[i]);
237 10 : fail_unless(tc_data_item[i] != INITPTR,
238 : "failed to add Test Case data item to list");
239 : }
240 :
241 1 : tm_set_tclist(tm_data_item, tc_list);
242 1 : result = tm_create_test_summary(tm_data_item);
243 1 : fail_unless(result != -1,
244 : "failed to create Test Summary data structure");
245 :
246 1 : tm_delete(test_module);
247 : }
248 1 : END_TEST
249 :
250 : /* ------------------------------------------------------------------------- */
251 :
252 1 : START_TEST(test_module_info_set_and_get_cfg_filename_list)
253 : {
254 1 : DLList* dllist = INITPTR;
255 : DLListIterator dllist_item;
256 : test_module_info_s* tm_data;
257 1 : DLList* test_case_list = INITPTR;
258 1 : DLList* list_ptr = INITPTR;
259 :
260 1 : dllist = dl_list_create();
261 1 : fail_unless(dllist != INITPTR, "failed to create list");
262 :
263 1 : tm_data = tm_create("test_module1.dat", INITPTR,0);
264 1 : fail_unless(tm_data != INITPTR,
265 : "failed to create Test Module Info data item");
266 :
267 1 : dllist_item = tm_add(dllist, tm_data);
268 1 : fail_unless(dllist_item != INITPTR,
269 : "failed to add Test Module Info data item");
270 :
271 1 : test_case_list = dl_list_create();
272 :
273 1 : tm_set_cfg_filenames(dllist_item, test_case_list);
274 :
275 1 : list_ptr = tm_get_cfg_filenames(dllist_item);
276 1 : fail_unless(list_ptr == test_case_list,
277 : "failed to set and get config filename list");
278 :
279 1 : tm_remove(dllist_item);
280 : }
281 1 : END_TEST
282 :
283 : /* ------------------------------------------------------------------------- */
284 :
285 1 : START_TEST(test_module_info_get_ptr_by_pid)
286 : {
287 1 : long TEST_PID = 40;
288 1 : DLList* tm_list = INITPTR;
289 : DLListIterator tm_data_item[10];
290 : test_module_info_s* test_module[10];
291 1 : DLListIterator found_data = INITPTR;
292 1 : long compare_pid = 0;
293 1 : long pid = 10;
294 1 : DLListIterator compare_data = INITPTR;
295 : int i;
296 :
297 1 : tm_list = dl_list_create();
298 1 : fail_unless(tm_list != INITPTR, "failed to create list");
299 :
300 11 : for (i = 0; i<10; i++) {
301 10 : test_module[i] = tm_create("test_module.dat", INITPTR,0);
302 10 : fail_unless(test_module[i] != INITPTR,
303 : "failed to create Test Module Info data item");
304 :
305 10 : tm_data_item[i] = tm_add(tm_list, test_module[i]);
306 10 : fail_unless(tm_data_item[i] != INITPTR,
307 : "failed to add Test Module Info data item");
308 :
309 10 : tm_set_pid(tm_data_item[i], pid);
310 :
311 10 : if (pid == TEST_PID) compare_data = tm_data_item[i];
312 10 : pid += 10;
313 : }
314 :
315 1 : found_data = tm_get_ptr_by_pid(tm_list, TEST_PID);
316 1 : fail_unless(found_data == compare_data,
317 : "failed to found Test Module Info data by PID");
318 :
319 1 : compare_pid = tm_get_pid(found_data);
320 1 : fail_unless(compare_pid == TEST_PID,
321 : "failed to set Test Module Info PID");
322 :
323 11 : for (i = 0; i<10; i++)
324 10 : free(test_module[i]);
325 :
326 1 : dl_list_free(&tm_list);
327 : }
328 1 : END_TEST
329 :
330 : /* ------------------------------------------------------------------------- */
331 :
332 1 : START_TEST(test_module_info_set_and_get_module_filename)
333 : {
334 1 : DLList* dllist = INITPTR;
335 : DLListIterator dllist_item;
336 : test_module_info_s* tm_data;
337 1 : filename_t TEST_FILENAME = "MODULE FILENAME TEST";
338 : filename_t module_filename;
339 1 : int result = 0;
340 :
341 1 : dllist = dl_list_create();
342 1 : fail_unless(dllist != INITPTR, "failed to create list");
343 :
344 1 : tm_data = tm_create(TEST_FILENAME, INITPTR,0);
345 1 : fail_unless(tm_data != INITPTR,
346 : "failed to create Test Module Info data item");
347 :
348 1 : dllist_item = tm_add(dllist, tm_data);
349 1 : fail_unless(dllist_item != INITPTR,
350 : "failed to add Test Module Info data item");
351 :
352 1 : tm_get_module_filename(dllist_item, module_filename);
353 1 : result = strcmp(module_filename, TEST_FILENAME);
354 :
355 1 : fail_unless(result == 0,
356 : "failed to set and get module filename");
357 :
358 1 : tm_remove(dllist_item);
359 : }
360 1 : END_TEST
361 :
362 : /* ------------------------------------------------------------------------- */
363 :
364 1 : START_TEST(test_module_info_ts_detail_expections)
365 : {
366 1 : DLList* tm_list = INITPTR;
367 : test_module_info_s* test_module;
368 : DLListIterator tm_data_item;
369 1 : filename_t TEST_MODULE_FILENAME = "TEST_MODULE.DAT";
370 1 : int count = 0;
371 :
372 1 : tm_list = dl_list_create();
373 1 : fail_unless(tm_list != INITPTR, "failed to create list");
374 :
375 1 : tm_data_item = INITPTR;
376 1 : tm_set_test_summary_detail(tm_data_item, TEST_RESULT_PASSED, 10);
377 1 : count = tm_get_test_summary_detail(tm_data_item, TEST_RESULT_PASSED);
378 1 : fail_unless(count == -1,
379 : "failed to check Test Module Info data INITPTR pointer");
380 :
381 1 : test_module = INITPTR;
382 1 : tm_data_item = tm_add(tm_list, test_module);
383 1 : fail_unless(tm_data_item != INITPTR,
384 : "failed to add Test Module Info data item to list");
385 :
386 1 : tm_set_test_summary_detail(tm_data_item, TEST_RESULT_FAILED, 10);
387 1 : count = tm_get_test_summary_detail(tm_data_item, TEST_RESULT_FAILED);
388 1 : fail_unless(count == -1,
389 : "failed to check Test Module Info data NULL pointer");
390 :
391 1 : test_module = tm_create(TEST_MODULE_FILENAME, INITPTR,0);
392 1 : fail_unless(test_module != NULL,
393 : "failed to create Test Module Info data item");
394 :
395 1 : tm_data_item = tm_add(tm_list, test_module);
396 1 : tm_set_test_summary_data(tm_data_item, INITPTR);
397 1 : tm_set_test_summary_detail(tm_data_item, TEST_RESULT_CRASHED, 10);
398 1 : count = tm_get_test_summary_detail(tm_data_item, TEST_RESULT_CRASHED);
399 1 : fail_unless(count == -1,
400 : "failed to check Test Summary data NULL pointer");
401 : }
402 1 : END_TEST
403 :
404 : /* ------------------------------------------------------------------------- */
405 :
406 1 : START_TEST(test_module_info_get_and_set_ts_details)
407 : {
408 1 : DLList* tm_list = INITPTR;
409 : test_module_info_s* test_module;
410 : DLListIterator tm_data_item;
411 1 : filename_t TEST_MODULE_FILENAME = "TEST_MODULE.DAT";
412 1 : int count = 0;
413 1 : int result = 0;
414 : int ts_type;
415 : int ts_test_count;
416 :
417 1 : tm_list = dl_list_create();
418 1 : fail_unless(tm_list != INITPTR, "failed to create list");
419 :
420 1 : test_module = tm_create(TEST_MODULE_FILENAME, INITPTR,0);
421 1 : fail_unless(test_module != INITPTR,
422 : "failed to create Test Module Info data item");
423 :
424 1 : tm_data_item = tm_add(tm_list, test_module);
425 1 : fail_unless(tm_data_item != INITPTR,
426 : "failed to add Test Module Info data item to list");
427 :
428 1 : result = tm_create_test_summary(tm_data_item);
429 1 : fail_unless(result == 1,
430 : "failed to create Test Summary data structure");
431 :
432 1 : tm_set_test_summary_detail(tm_data_item, TEST_RESULT_NOT_RUN, 20);
433 1 : count = tm_get_test_summary_detail(tm_data_item, TEST_RESULT_NOT_RUN);
434 1 : fail_unless(count == -2,
435 : "failed to check use of invalid enum value (check #1)");
436 :
437 1 : tm_set_test_summary_detail(tm_data_item, TEST_RESULT_ALL, 20);
438 1 : count = tm_get_test_summary_detail(tm_data_item, TEST_RESULT_ALL);
439 1 : fail_unless(count == -2,
440 : "failed to check use of invalid enum value (check #2)");
441 :
442 1 : ts_type = TEST_RESULT_PASSED;
443 1 : ts_test_count = 10;
444 :
445 7 : while (ts_type < TEST_RESULT_ALL) {
446 5 : tm_set_test_summary_detail(tm_data_item, ts_type, ts_test_count);
447 5 : count = tm_get_test_summary_detail(tm_data_item, ts_type);
448 5 : fail_unless(count == ts_test_count,
449 : "failed to check Test Summary data details");
450 5 : ts_type++;
451 5 : ts_test_count += 10;
452 : }
453 : }
454 1 : END_TEST
455 :
456 : /* ------------------------------------------------------------------------- */
457 :
458 1 : START_TEST(test_module_info_set_and_get_tclist)
459 : {
460 1 : DLList* tm_list = INITPTR;
461 : test_module_info_s* test_module;
462 : DLListIterator tm_data_item;
463 :
464 1 : DLList* tc_list = INITPTR;
465 : DLListIterator tc_data_item[10];
466 : test_case_s* tc_data[10];
467 1 : DLList* tc_list_test = INITPTR;
468 : int i;
469 :
470 1 : tm_list = dl_list_create();
471 1 : fail_unless(tm_list != INITPTR, "failed to create list");
472 :
473 1 : test_module = tm_create("TEST_MODULE.DAT", INITPTR,0);
474 1 : fail_unless(test_module != INITPTR,
475 : "failed to create Test Module Info data item");
476 :
477 1 : tm_data_item = tm_add(tm_list, test_module);
478 1 : fail_unless(tm_data_item != INITPTR,
479 : "failed to add Test Module Info data item to list");
480 :
481 1 : tc_list = dl_list_create();
482 1 : fail_unless(tc_list != INITPTR, "failed to create list");
483 :
484 11 : for (i=0; i<10; i++) {
485 10 : tc_data[i] = tc_create(NULL, "TESTCASE.CFG", "Test Case");
486 10 : fail_unless(tc_data[i] != INITPTR,
487 : "failed to create Test Case data item");
488 10 : tc_data_item[i] = tc_add(tc_list, (void*)tc_data[i]);
489 10 : fail_unless(tc_data_item[i] != INITPTR,
490 : "failed to add data item to Test Case linked list");
491 : }
492 :
493 1 : tm_set_tclist(tm_data_item, tc_list);
494 1 : tc_list_test = tm_get_tclist(tm_data_item);
495 1 : fail_unless(tc_list_test == tc_list,
496 : "failed to set and get Test Case list to Test Module Info data");
497 :
498 1 : tm_remove(tm_data_item);
499 1 : dl_list_free(&tm_list);
500 : }
501 1 : END_TEST
502 :
503 : /* ------------------------------------------------------------------------- */
504 :
505 1 : START_TEST(test_module_info_set_and_get_status)
506 : {
507 1 : DLList* tm_list = INITPTR;
508 : DLListIterator tm_data_item[2];
509 : test_module_info_s* tm_data;
510 1 : int TEST_STATUS = TEST_MODULE_READY;
511 1 : int status = TEST_MODULE_NOT_STARTED;
512 1 : int result = 0;
513 :
514 1 : tm_list = dl_list_create();
515 1 : fail_unless(tm_list != INITPTR, "failed to create list");
516 :
517 1 : tm_data_item[0] = tm_add(tm_list, INITPTR);
518 1 : fail_unless(tm_data_item[0] != INITPTR,
519 : "failed to add Test Module Info data item");
520 :
521 1 : tm_set_status(tm_data_item[0], TEST_STATUS);
522 1 : result = tm_get_status(tm_data_item[0]);
523 1 : fail_unless(result == -1,
524 : "failed to use INITPTR Test Module Info data with status value");
525 :
526 1 : tm_data = tm_create("TEST_MODULE.DAT", INITPTR,0);
527 1 : fail_unless(tm_data != INITPTR,
528 : "failed to create Test Module Info data item");
529 :
530 1 : tm_data_item[1] = tm_add(tm_list, tm_data);
531 1 : fail_unless(tm_data_item[1] != INITPTR,
532 : "failed to add Test Module Info data item");
533 :
534 1 : tm_set_status(tm_data_item[1], TEST_STATUS);
535 1 : status = tm_get_status(tm_data_item[1]);
536 1 : fail_unless(status == TEST_STATUS,
537 : "failed to add/get data item");
538 :
539 1 : tm_remove(tm_data_item[0]);
540 1 : tm_remove(tm_data_item[1]);
541 1 : dl_list_free(&tm_list);
542 : }
543 1 : END_TEST
544 :
545 : /* ------------------------------------------------------------------------- */
546 :
547 1 : START_TEST(test_module_info_get_status_without_tm_data)
548 : {
549 1 : DLList* tm_list = INITPTR;
550 1 : DLListIterator tm_data_item = INITPTR;
551 1 : int status = TEST_MODULE_NOT_STARTED;
552 :
553 1 : tm_list = dl_list_create();
554 1 : fail_unless(tm_list != INITPTR, "failed to create list");
555 :
556 1 : tm_data_item = tm_add(tm_list, INITPTR);
557 1 : fail_unless(dl_list_data(tm_data_item) == INITPTR,
558 : "failed to add null Test Module Info data item");
559 :
560 1 : dl_list_free(&tm_list);
561 : }
562 1 : END_TEST
563 :
564 : /* ------------------------------------------------------------------------- */
565 :
566 1 : START_TEST(test_module_info_get_test_summary_data)
567 : {
568 1 : DLList* tm_list = INITPTR;
569 : DLListIterator tm_data_item;
570 1 : test_module_info_s* test_module = INITPTR;
571 1 : test_summary_s* test_summary = INITPTR;
572 1 : test_summary_s* ts_check = INITPTR;
573 1 : int result = 0;
574 :
575 1 : tm_list = dl_list_create();
576 1 : fail_unless(tm_list != INITPTR, "failed to create list");
577 :
578 1 : tm_data_item = INITPTR;
579 1 : ts_check = tm_get_test_summary_data(tm_data_item);
580 1 : fail_unless(ts_check == INITPTR,
581 : "failed to check INITPTR (Test Summary)");
582 :
583 1 : tm_data_item = tm_add(tm_list, INITPTR);
584 1 : fail_unless(dl_list_data(tm_data_item) == INITPTR,
585 : "failed to add INITPTR Test Module Info data item");
586 :
587 1 : test_module = tm_create("TEST_MODULE.DAT", INITPTR,0);
588 1 : fail_unless(test_module != INITPTR,
589 : "failed to create Test Module Info data");
590 :
591 1 : tm_data_item = tm_add(tm_list, test_module);
592 1 : fail_unless(tm_data_item != INITPTR,
593 : "failed to add null Test Module Info data item");
594 :
595 1 : result = tm_create_test_summary(tm_data_item);
596 1 : fail_unless(result == 1,
597 : "failed to create Test Summary data structure");
598 :
599 1 : tm_set_test_summary_data(tm_data_item, test_summary);
600 1 : ts_check = tm_get_test_summary_data(tm_data_item);
601 1 : fail_unless(ts_check == test_summary,
602 : "failed to get Test Summary data");
603 : }
604 1 : END_TEST
605 :
606 : /* ================= TEST CASE API TESTING FUNCTIONS ======================= */
607 :
608 1 : START_TEST(test_case_create_data_item)
609 : {
610 1 : test_case_s* tc_data = INITPTR;
611 :
612 1 : tc_data = tc_create(NULL,
613 : "testcase1.cfg",
614 : "Test Case #1");
615 1 : fail_unless (tc_data != INITPTR,
616 : "failed to create Test Case data item");
617 :
618 1 : if (tc_data != INITPTR)
619 1 : free(tc_data);
620 : }
621 1 : END_TEST
622 :
623 : /* ------------------------------------------------------------------------- */
624 :
625 1 : START_TEST(test_case_title_under_size_limit)
626 : {
627 1 : test_case_s* tc_data = INITPTR;
628 1 : int TEST_SIZE = MaxTestCaseName - 10;
629 1 : char TEST_LONG_TITLE[TEST_SIZE];
630 1 : int i, n = 0;
631 :
632 246 : for (i=0; i<TEST_SIZE-1; i++) {
633 245 : TEST_LONG_TITLE[i] = 48 + n;
634 245 : n++;
635 245 : if (n>9) n = 0;
636 : }
637 1 : TEST_LONG_TITLE[TEST_SIZE] = '\0';
638 :
639 1 : tc_data = tc_create(NULL,
640 : "testcase2.cfg",
641 : TEST_LONG_TITLE);
642 :
643 1 : fail_if(tc_data == INITPTR,
644 : "failed to test valid length title string");
645 : }
646 1 : END_TEST
647 :
648 : /* ------------------------------------------------------------------------- */
649 :
650 1 : START_TEST(test_case_title_over_size_limit)
651 : {
652 1 : test_case_s* tc_data = INITPTR;
653 1 : int TEST_SIZE = MaxTestCaseName + 10;
654 1 : char TEST_LONG_TITLE[TEST_SIZE];
655 1 : int i, n = 0;
656 :
657 266 : for (i=0; i<TEST_SIZE-1; i++) {
658 265 : TEST_LONG_TITLE[i] = 48 + n;
659 265 : n++;
660 265 : if (n>9) n = 0;
661 : }
662 1 : TEST_LONG_TITLE[TEST_SIZE] = '\0';
663 :
664 1 : tc_data = tc_create(NULL,
665 : "testcase3.cfg",
666 : TEST_LONG_TITLE);
667 :
668 1 : fail_if(tc_data != INITPTR,
669 : "failed to test too big title string");
670 : }
671 1 : END_TEST
672 :
673 : /* ------------------------------------------------------------------------- */
674 :
675 1 : START_TEST(test_case_add_to_list)
676 : {
677 1 : DLList* dllist = NULL;
678 1 : DLListIterator dllist_item = NULL;
679 1 : test_case_s* tc_data = INITPTR;
680 :
681 1 : dllist = dl_list_create();
682 1 : fail_unless (dllist != NULL, "failed to create list");
683 :
684 1 : tc_data = tc_create(NULL,
685 : "testcase4.cfg",
686 : "Test Case #4");
687 1 : fail_unless (tc_data != INITPTR, "failed to create Test Case data item");
688 :
689 1 : dllist_item = tc_add(dllist, (void*)tc_data);
690 1 : fail_unless (dllist_item != NULL,
691 : "failed to add data item to Test Case linked list");
692 : }
693 1 : END_TEST
694 :
695 : /* ------------------------------------------------------------------------- */
696 :
697 1 : START_TEST(test_case_delete_data)
698 : {
699 1 : test_case_s* test_case = INITPTR;
700 :
701 1 : test_case = tc_create(NULL,
702 : "testcase5.cfg",
703 : "Test Case #5");
704 1 : fail_unless(test_case != INITPTR, "failed to create Test Case data item");
705 :
706 1 : tc_delete(test_case);
707 : }
708 1 : END_TEST
709 :
710 : /* ------------------------------------------------------------------------- */
711 :
712 1 : START_TEST(test_case_remove_from_list)
713 : {
714 1 : DLList* tc_list = NULL;
715 : DLListIterator tc_data_item[5];
716 : test_case_s* test_case[5];
717 1 : const int CHECK_ID = 3;
718 1 : DLListIterator check_item = INITPTR;
719 1 : BOOL data_found = FALSE;
720 : int i;
721 :
722 1 : tc_list = dl_list_create();
723 1 : fail_unless (tc_list != INITPTR, "failed to create list");
724 :
725 6 : for (i=0; i<5; i++) {
726 5 : test_case[i] = tc_create(NULL, "testcase.cfg", "Test Case");
727 5 : fail_unless(test_case[i] != INITPTR,
728 : "failed to create Test Case data item");
729 5 : tc_data_item[i] = tc_add(tc_list, test_case[i]);
730 5 : fail_unless(tc_data_item != NULL,
731 : "failed to add data item to Test Case linked list");
732 : }
733 :
734 1 : tc_remove(tc_data_item[CHECK_ID]);
735 :
736 1 : check_item = dl_list_head(tc_list);
737 1 : i = 0;
738 1 : data_found = FALSE;
739 :
740 6 : while (check_item != INITPTR) {
741 4 : if (check_item->data_ == tc_data_item[CHECK_ID])
742 0 : data_found = TRUE;
743 4 : check_item = dl_list_next(check_item);
744 4 : i++;
745 : }
746 :
747 1 : fail_unless((i == 4 && data_found == FALSE),
748 : "failed to remove Test Case data item from list");
749 : }
750 1 : END_TEST
751 :
752 : /* ------------------------------------------------------------------------- */
753 :
754 1 : START_TEST(test_case_set_and_get_tc_id)
755 : {
756 1 : DLList* tc_list = INITPTR;
757 1 : DLListIterator tc_data_item = INITPTR;
758 1 : test_case_s* test_case = INITPTR;
759 1 : const int TEST_ID = 100;
760 1 : int test_case_id = 0;
761 :
762 1 : tc_list = dl_list_create();
763 1 : fail_unless(tc_list != INITPTR, "failed to create list");
764 :
765 1 : tc_data_item = tc_add(tc_list, NULL);
766 1 : fail_unless(tc_data_item != INITPTR,
767 : "failed to add null Test Case data item");
768 :
769 1 : test_case_id = tc_get_id(tc_data_item);
770 1 : fail_unless(test_case_id == -1,
771 : "failed to check Test Case ID error handling");
772 :
773 1 : test_case = tc_create(NULL,
774 : "TEST_CASE.CFG",
775 : "Test Case");
776 1 : fail_unless(test_case != INITPTR,
777 : "failed to create Test Case data item");
778 :
779 1 : tc_data_item = tc_add(tc_list, (void*)test_case);
780 1 : fail_unless(tc_data_item != INITPTR,
781 : "failed to add data item to Test Case linked list");
782 :
783 1 : tc_set_id(tc_data_item, TEST_ID);
784 1 : test_case_id = tc_get_id(tc_data_item);
785 1 : fail_unless(test_case_id == TEST_ID,
786 : "failed to execute Test Case ID data handling");
787 :
788 1 : tc_remove(tc_data_item);
789 1 : dl_list_free(&tc_list);
790 : }
791 1 : END_TEST
792 :
793 : /* ------------------------------------------------------------------------- */
794 :
795 1 : START_TEST(test_case_set_and_get_tc_group_id)
796 : {
797 1 : DLList* tc_list = NULL;
798 1 : DLListIterator tc_data_item = NULL;
799 1 : test_case_s* test_case = INITPTR;
800 1 : const int TEST_GROUP_ID = 100;
801 1 : int test_case_group_id = 0;
802 :
803 1 : tc_list = dl_list_create();
804 1 : fail_unless(tc_list != NULL, "failed to create list");
805 :
806 1 : tc_data_item = tc_add(tc_list, NULL);
807 1 : fail_unless(tc_data_item != INITPTR,
808 : "failed to add null Test Case data item");
809 :
810 1 : test_case_group_id = tc_get_group_id(tc_data_item);
811 1 : fail_unless (test_case_group_id == -1,
812 : "failed to chech Test Case Group ID error handling");
813 :
814 1 : test_case = tc_create(NULL, "TESTCASE.CFG", "Test Case");
815 1 : fail_unless(test_case != INITPTR,
816 : "failed to create Test Case data item");
817 :
818 1 : tc_data_item = tc_add(tc_list, (void*)test_case);
819 1 : fail_unless(tc_data_item != INITPTR,
820 : "failed to add data item to Test Case linked list");
821 :
822 1 : tc_set_group_id(tc_data_item, TEST_GROUP_ID);
823 1 : test_case_group_id = tc_get_group_id(tc_data_item);
824 1 : fail_unless (test_case_group_id == TEST_GROUP_ID,
825 : "failed to execute Test Case group ID data handling");
826 :
827 1 : tc_remove(tc_data_item);
828 1 : dl_list_free(&tc_list);
829 : }
830 1 : END_TEST
831 :
832 : /* ------------------------------------------------------------------------- */
833 :
834 1 : START_TEST(test_case_set_and_get_tc_title)
835 : {
836 1 : DLList* tc_list = INITPTR;
837 1 : DLListIterator tc_data_item = INITPTR;
838 1 : test_case_s* test_case = INITPTR;
839 1 : title_string_t TEST_TITLE = "TEST CASE TITLE";
840 : title_string_t test_case_title;
841 1 : int result = 0;
842 :
843 1 : tc_list = dl_list_create();
844 1 : fail_unless(tc_list != INITPTR, "failed to create list");
845 :
846 1 : tc_data_item = tc_add(tc_list, NULL);
847 1 : fail_unless(tc_data_item != INITPTR,
848 : "failed to add null Test Case data item to list");
849 :
850 1 : result = tc_get_title(tc_data_item, test_case_title);
851 1 : fail_unless (result == -1,
852 : "failed to check Test Case title error handling");
853 :
854 1 : test_case = tc_create(NULL, "TEST_CASE.CFG", TEST_TITLE);
855 1 : fail_unless(test_case != INITPTR,
856 : "failed to create Test Case data item");
857 :
858 1 : tc_data_item = tc_add(tc_list, (void*)test_case);
859 1 : fail_unless(tc_data_item != INITPTR,
860 : "failed to add data item to Test Case linked list");
861 :
862 1 : result = tc_get_title(tc_data_item, test_case_title);
863 1 : fail_unless (result == 1,
864 : "failed to get title from Test Case data item");
865 1 : fail_unless (strncmp(test_case_title, TEST_TITLE,
866 : strlen(test_case_title)) == 0,
867 : "failed with title functions, strings not matched");
868 :
869 1 : tc_remove(tc_data_item);
870 1 : dl_list_free(&tc_list);
871 : }
872 1 : END_TEST
873 :
874 : /* ------------------------------------------------------------------------- */
875 :
876 1 : START_TEST(test_case_set_and_get_status)
877 : {
878 1 : DLList* dllist = NULL;
879 1 : DLListIterator dllist_item = NULL;
880 1 : test_case_s* tc_data = INITPTR;
881 1 : int test_status = TEST_RESULT_NOT_RUN;
882 :
883 1 : dllist = dl_list_create();
884 1 : fail_unless (dllist != NULL, "failed to create list");
885 :
886 1 : tc_data = tc_create(NULL,
887 : "testcase9.cfg",
888 : "Test Case #9");
889 1 : fail_unless (tc_data != INITPTR, "failed to create Test Case data item");
890 :
891 1 : dllist_item = tc_add(dllist, (void*)tc_data);
892 1 : fail_unless (dllist_item != NULL,
893 : "failed to add data item to Test Case linked list");
894 :
895 1 : tc_set_status(dllist_item, TEST_RESULT_PASSED);
896 1 : test_status = tc_get_status(dllist_item);
897 1 : fail_unless (test_status == TEST_RESULT_PASSED,
898 : "failed to execute Test Case status data handling");
899 : }
900 1 : END_TEST
901 :
902 : /* ------------------------------------------------------------------------- */
903 :
904 1 : START_TEST(test_case_set_and_get_config_filename)
905 : {
906 1 : DLList* tc_list = INITPTR;
907 1 : DLListIterator tc_data_item = INITPTR;
908 1 : test_case_s* test_case = INITPTR;
909 1 : filename_t TEST_CONFIG_FILENAME = "TEST_CASE.CFG";
910 : filename_t tc_check_cfg_filename;
911 : int compare_result;
912 :
913 1 : tc_list = dl_list_create();
914 1 : fail_unless(tc_list != INITPTR, "failed to create list");
915 :
916 1 : test_case = tc_create(NULL, "TEST_CASE.CFG", "Test Case");
917 1 : fail_unless(test_case != NULL,
918 : "failed to create Test Case data item");
919 :
920 1 : tc_data_item = tc_add(tc_list, (void*)test_case);
921 1 : fail_unless(tc_data_item != NULL,
922 : "failed to add data item to Test Case linked list");
923 :
924 1 : tc_set_cfg_filename(tc_data_item, TEST_CONFIG_FILENAME);
925 1 : tc_get_cfg_filename(tc_data_item, tc_check_cfg_filename);
926 1 : compare_result = strncmp(tc_check_cfg_filename, TEST_CONFIG_FILENAME,
927 : strlen(tc_check_cfg_filename));
928 1 : fail_unless(compare_result == 0,
929 : "failed to check Test Case config filename handling");
930 :
931 1 : tc_remove(tc_data_item);
932 1 : dl_list_free(&tc_list);
933 : }
934 1 : END_TEST
935 :
936 : /* ------------------------------------------------------------------------- */
937 :
938 1 : START_TEST(test_case_set_and_get_tc_priority)
939 : {
940 1 : DLList* tc_list = INITPTR;
941 1 : DLListIterator tc_data_item = INITPTR;
942 1 : test_case_s* test_case = INITPTR;
943 1 : int TEST_PRIORITY = 10;
944 1 : int check_priority = 0;
945 :
946 1 : tc_list = dl_list_create();
947 1 : fail_unless(tc_list != INITPTR, "failed to create list");
948 :
949 1 : tc_data_item = tc_add(tc_list, NULL);
950 1 : fail_unless(tc_data_item != INITPTR,
951 : "failed to add null Test Case data item to list");
952 :
953 1 : tc_set_priority(tc_data_item, TEST_PRIORITY);
954 1 : check_priority = tc_get_priority(tc_data_item);
955 1 : fail_unless(check_priority == -1,
956 : "failed to check Test Case priority error handling");
957 :
958 1 : test_case = tc_create(NULL, "TEST_CASE.CFG", "Test Case");
959 1 : fail_unless(test_case != INITPTR,
960 : "failed to create Test Case data item");
961 :
962 1 : tc_data_item = tc_add(tc_list, (void*)test_case);
963 1 : fail_unless(tc_data_item != NULL,
964 : "failed to add data item to Test Case linked list");
965 :
966 1 : tc_set_priority(tc_data_item, TEST_PRIORITY);
967 1 : check_priority = tc_get_priority(tc_data_item);
968 1 : fail_unless(check_priority == TEST_PRIORITY,
969 : "failed to check Test Case priority data handling");
970 :
971 1 : tc_remove(tc_data_item);
972 1 : dl_list_free(&tc_list);
973 : }
974 1 : END_TEST
975 :
976 : /* ------------------------------------------------------------------------- */
977 :
978 1 : START_TEST(test_case_set_and_get_test_module_ptr)
979 : {
980 1 : DLList* tc_list = INITPTR;
981 1 : DLListIterator tc_data_item = INITPTR;
982 1 : test_case_s* test_case = INITPTR;
983 : DLListIterator check_tm_ptr;
984 :
985 1 : DLList* tm_list = INITPTR;
986 1 : DLListIterator tm_data_item = INITPTR;
987 1 : test_module_info_s* test_module = NULL;
988 :
989 1 : tc_list = dl_list_create();
990 1 : fail_unless(tc_list != INITPTR, "failed to create list");
991 :
992 1 : tc_data_item = tc_add(tc_list, NULL);
993 1 : fail_unless(tc_data_item != INITPTR,
994 : "failed to add null Test Case data item to list");
995 :
996 1 : check_tm_ptr = INITPTR;
997 1 : check_tm_ptr = tc_get_test_module_ptr(tc_data_item);
998 1 : fail_unless(check_tm_ptr == INITPTR,
999 : "failed to check Test Case test module ptr error handling");
1000 :
1001 1 : tm_list = dl_list_create();
1002 1 : fail_unless(tm_list != INITPTR, "failed to create list");
1003 :
1004 1 : test_module = tm_create("TEST_MODULE.DAT", INITPTR,0);
1005 1 : fail_unless(test_module != INITPTR,
1006 : "failed to create Test Module data structure");
1007 :
1008 1 : tm_data_item = tm_add(tm_list, test_module);
1009 1 : fail_unless(tm_data_item != INITPTR,
1010 : "failed to add Test Module data item to list");
1011 :
1012 1 : test_case = tc_create(tm_data_item, "TEST_CASE.CFG", "Test Case");
1013 1 : fail_unless(test_case != NULL,
1014 : "failed to create Test Case data item");
1015 :
1016 1 : tc_data_item = tc_add(tc_list, (void*)test_case);
1017 1 : fail_unless(tc_data_item != NULL,
1018 : "failed to add data item to Test Case linked list");
1019 :
1020 1 : tc_set_test_module_ptr(tc_data_item, tm_data_item);
1021 1 : check_tm_ptr = tc_get_test_module_ptr(tc_data_item);
1022 1 : fail_unless(check_tm_ptr == tm_data_item,
1023 : "failed to check Test Case test module ptr data handling");
1024 :
1025 1 : tm_remove(tm_data_item);
1026 1 : dl_list_free(&tm_list);
1027 :
1028 1 : tc_remove(tc_data_item);
1029 1 : dl_list_free(&tc_list);
1030 : }
1031 1 : END_TEST
1032 :
1033 : /* ------------------------------------------------------------------------- */
1034 :
1035 1 : START_TEST(test_case_set_and_get_tr_list)
1036 : {
1037 1 : DLList* tc_list = INITPTR;
1038 1 : DLListIterator tc_data_item = INITPTR;
1039 1 : test_case_s* test_case = INITPTR;
1040 1 : DLList* tr_list = INITPTR;
1041 : DLListIterator tr_data_item[10];
1042 : test_result_s* test_result[10];
1043 1 : DLList* compare_list = INITPTR;
1044 : int i;
1045 :
1046 1 : tc_list = dl_list_create();
1047 1 : fail_unless(tc_list != INITPTR,
1048 : "failed to create Test Case list");
1049 :
1050 1 : test_case = tc_create(NULL, "TEST_CASE.CFG", "Test Case");
1051 1 : fail_unless(test_case != INITPTR,
1052 : "failed to create Test Case data item");
1053 :
1054 1 : tc_data_item = tc_add(tc_list, test_case);
1055 1 : fail_unless(tc_data_item != INITPTR,
1056 : "failed to add data item to Test Case list");
1057 :
1058 1 : tr_list = dl_list_create();
1059 1 : fail_unless(tr_list != INITPTR,
1060 : "failed to create Test Result list");
1061 :
1062 11 : for (i=0; i<10; i++) {
1063 10 : test_result[i] = tr_create_data_item(tc_data_item);
1064 10 : fail_unless(test_result[i] != NULL,
1065 : "failed to create Test Result data item");
1066 :
1067 10 : tr_data_item[i] = tr_add(tr_list, test_result[i]);
1068 10 : fail_unless(tr_data_item[i] != INITPTR,
1069 : "failed to add data item to Test Result list");
1070 : }
1071 :
1072 1 : tc_set_tr_list(tc_data_item, tr_list);
1073 1 : compare_list = tc_get_tr_list(tc_data_item);
1074 1 : fail_unless(compare_list == tr_list,
1075 : "failed to check Test Result list data handling");
1076 :
1077 1 : tc_remove(tc_data_item);
1078 1 : dl_list_free(&tc_list);
1079 : }
1080 1 : END_TEST
1081 :
1082 : /* ================= TEST RESULT API TESTING FUNCTIONS ===================== */
1083 :
1084 1 : START_TEST(test_result_create_tr_data_structure)
1085 : {
1086 1 : test_result_s* test_result = NULL;
1087 1 : DLListIterator TEST_CASE_NULL = INITPTR;
1088 :
1089 1 : test_result = tr_create_data_item(TEST_CASE_NULL);
1090 :
1091 1 : fail_unless(test_result != NULL,
1092 : "failed to create Test Result data structure");
1093 : }
1094 1 : END_TEST
1095 :
1096 : /* ------------------------------------------------------------------------- */
1097 :
1098 1 : START_TEST(test_result_add_tr_data_item)
1099 : {
1100 1 : DLList* dllist = INITPTR;
1101 1 : DLListIterator dllist_item = INITPTR;
1102 1 : DLListIterator TEST_CASE_NULL = INITPTR;
1103 :
1104 1 : test_result_s* test_result = NULL;
1105 :
1106 1 : dllist = dl_list_create();
1107 1 : fail_unless (dllist != NULL, "failed to create list");
1108 :
1109 1 : test_result = tr_create_data_item(TEST_CASE_NULL);
1110 1 : fail_unless(test_result != NULL,
1111 : "failed to create Test Result data structure");
1112 :
1113 1 : dllist_item = tr_add(dllist, test_result);
1114 1 : fail_unless(dllist != INITPTR,
1115 : "failed to add Test Result data item to list");
1116 : }
1117 1 : END_TEST
1118 :
1119 : /* ------------------------------------------------------------------------- */
1120 :
1121 1 : START_TEST(test_result_remove_tr_data_item)
1122 : {
1123 1 : DLList* dllist = INITPTR;
1124 1 : DLListIterator dllist_item = INITPTR;
1125 1 : DLListIterator TEST_CASE_NULL = INITPTR;
1126 :
1127 1 : test_result_s* test_result = NULL;
1128 :
1129 1 : dllist = dl_list_create();
1130 1 : fail_unless (dllist != NULL, "failed to create list");
1131 :
1132 1 : test_result = tr_create_data_item(TEST_CASE_NULL);
1133 1 : fail_unless(test_result != NULL,
1134 : "failed to create Test Result data structure");
1135 :
1136 1 : dllist_item = tr_add(dllist, test_result);
1137 1 : fail_unless(dllist_item != INITPTR,
1138 : "failed to add Test Result data item to list");
1139 :
1140 1 : tr_remove(dllist_item);
1141 1 : fail_unless(dllist_item != INITPTR,
1142 : "failed to remove Test Result Data item");
1143 : }
1144 1 : END_TEST
1145 :
1146 : /* ------------------------------------------------------------------------- */
1147 :
1148 1 : START_TEST(test_result_set_and_get_result_type)
1149 : {
1150 1 : DLList* dllist = INITPTR;
1151 1 : DLListIterator dllist_item = INITPTR;
1152 1 : DLListIterator TEST_CASE_NULL = INITPTR;
1153 1 : int TEST_RESULT_TYPE = TEST_RESULT_PASSED;
1154 1 : int result_type = TEST_RESULT_NOT_RUN;
1155 :
1156 : test_result_s* test_result;
1157 :
1158 1 : dllist = dl_list_create();
1159 1 : fail_unless (dllist != NULL, "failed to create list");
1160 :
1161 1 : tr_set_result_type(dllist_item, TEST_RESULT_TYPE);
1162 1 : result_type = tr_get_result_type(dllist_item);
1163 1 : fail_unless (result_type == -1,
1164 : "failed to check Test Result INITPTR pointer");
1165 :
1166 1 : test_result = NULL;
1167 1 : dllist_item = tr_add(dllist, test_result);
1168 1 : fail_unless(dllist_item != INITPTR,
1169 : "failed to add Test Result data item to list");
1170 :
1171 1 : tr_set_result_type(dllist_item, TEST_RESULT_TYPE);
1172 1 : result_type = tr_get_result_type(dllist_item);
1173 :
1174 1 : fail_unless (result_type == -1,
1175 : "failed to check Test Result without data item");
1176 :
1177 1 : test_result = tr_create_data_item(TEST_CASE_NULL);
1178 1 : dllist_item = tr_add(dllist, test_result);
1179 1 : fail_unless(dllist != INITPTR,
1180 : "failed to add Test Result data item to list");
1181 :
1182 1 : tr_set_result_type(dllist_item, TEST_RESULT_TYPE);
1183 1 : result_type = tr_get_result_type(dllist_item);
1184 1 : fail_unless (result_type == TEST_RESULT_TYPE,
1185 : "failed to set Test Result type value");
1186 : }
1187 1 : END_TEST
1188 :
1189 : /* ------------------------------------------------------------------------- */
1190 :
1191 1 : START_TEST(test_result_set_and_get_result_code)
1192 : {
1193 1 : DLList* dllist = INITPTR;
1194 1 : DLListIterator dllist_item = INITPTR;
1195 1 : DLListIterator TEST_CASE_NULL = INITPTR;
1196 1 : int TEST_RESULT_CODE = 123;
1197 1 : int result_code = 0;
1198 :
1199 : test_result_s* test_result;
1200 :
1201 1 : dllist = dl_list_create();
1202 1 : fail_unless (dllist != NULL, "failed to create list");
1203 :
1204 1 : tr_set_result_code(dllist_item, TEST_RESULT_CODE);
1205 1 : result_code = tr_get_result_code(dllist_item);
1206 1 : fail_unless (result_code == -1,
1207 : "failed to check Test Result INITPTR pointer");
1208 :
1209 1 : test_result = NULL;
1210 1 : dllist_item = tr_add(dllist, test_result);
1211 1 : fail_unless(dllist_item != INITPTR,
1212 : "failed to add Test Result data item to list");
1213 :
1214 1 : tr_set_result_code(dllist_item, TEST_RESULT_CODE);
1215 1 : result_code = tr_get_result_code(dllist_item);
1216 1 : fail_unless (result_code == -1,
1217 : "failed to check Test Result without data item");
1218 :
1219 1 : test_result = tr_create_data_item(TEST_CASE_NULL);
1220 1 : dllist_item = tr_add(dllist, test_result);
1221 1 : fail_unless(dllist != INITPTR,
1222 : "failed to add Test Result data item to list");
1223 :
1224 1 : tr_set_result_code(dllist_item, TEST_RESULT_CODE);
1225 1 : result_code = tr_get_result_code(dllist_item);
1226 1 : fail_unless (result_code == TEST_RESULT_CODE,
1227 : "failed to set Test Result code value");
1228 : }
1229 1 : END_TEST
1230 :
1231 : /* ------------------------------------------------------------------------- */
1232 :
1233 1 : START_TEST(test_result_set_and_get_result_description)
1234 : {
1235 1 : DLList* dllist = INITPTR;
1236 1 : DLListIterator dllist_item = INITPTR;
1237 1 : DLListIterator TEST_CASE_EMPTY = INITPTR;
1238 1 : result_description_t TEST_RESULT_DESCRIPTION = "DESCRIPTION";
1239 1 : result_description_t test_result_desc = "";
1240 : test_result_s* test_result;
1241 :
1242 1 : dllist = dl_list_create();
1243 1 : fail_unless (dllist != NULL, "failed to create list");
1244 :
1245 1 : tr_set_result_description(dllist_item, TEST_RESULT_DESCRIPTION);
1246 1 : tr_get_result_description(dllist_item, test_result_desc);
1247 1 : fail_unless (strlen(test_result_desc) == 0,
1248 : "failed to check Test Result INITPTR pointer");
1249 :
1250 1 : test_result = NULL;
1251 1 : dllist_item = tr_add(dllist, test_result);
1252 1 : fail_unless(dllist_item != INITPTR,
1253 : "failed to add Test Result data item to list");
1254 :
1255 1 : tr_set_result_description(dllist_item, TEST_RESULT_DESCRIPTION);
1256 1 : tr_get_result_description(dllist_item, test_result_desc);
1257 1 : fail_unless (strlen(test_result_desc) == 0,
1258 : "failed to check Test Result without data item");
1259 :
1260 1 : test_result = tr_create_data_item(TEST_CASE_EMPTY);
1261 1 : dllist_item = tr_add(dllist, test_result);
1262 1 : fail_unless(dllist != INITPTR,
1263 : "failed to add Test Result data item to list");
1264 :
1265 1 : tr_set_result_description(dllist_item, TEST_RESULT_DESCRIPTION);
1266 1 : tr_get_result_description(dllist_item, test_result_desc);
1267 1 : fail_unless (strncmp(test_result_desc, TEST_RESULT_DESCRIPTION,
1268 : strlen(test_result_desc)) == 0,
1269 : "failed to set Test Result description text");
1270 : }
1271 1 : END_TEST
1272 :
1273 : /* ------------------------------------------------------------------------- */
1274 :
1275 1 : START_TEST(test_result_start_and_end_time_data_use)
1276 : {
1277 1 : DLList* tr_list = INITPTR;
1278 1 : DLListIterator tr_data_item = INITPTR;
1279 1 : test_result_s* test_result = NULL;
1280 1 : long TEST_START_TIME = 10;
1281 1 : long TEST_END_TIME = 1000;
1282 : long check_time;
1283 :
1284 1 : tr_list = dl_list_create();
1285 1 : fail_unless(tr_list != INITPTR, "failed to create list");
1286 :
1287 1 : test_result = tr_create_data_item(INITPTR);
1288 1 : fail_unless(test_result != NULL,
1289 : "failed to create Test Result data item");
1290 :
1291 1 : tr_data_item = tr_add(tr_list, test_result);
1292 1 : fail_unless(tr_data_item != INITPTR,
1293 : "failed to add Test Result data item to list");
1294 :
1295 1 : check_time = 0;
1296 1 : tr_set_start_time(tr_data_item, TEST_START_TIME);
1297 1 : check_time = tr_get_start_time(tr_data_item);
1298 1 : fail_unless(check_time == TEST_START_TIME,
1299 : "failed to test Test Result start time handling");
1300 :
1301 1 : check_time = 0;
1302 1 : tr_set_end_time(tr_data_item, TEST_END_TIME);
1303 1 : check_time = tr_get_end_time(tr_data_item);
1304 1 : fail_unless(check_time == TEST_END_TIME,
1305 : "failed to test Test Result end time handling");
1306 :
1307 1 : tr_remove(tr_data_item);
1308 1 : dl_list_free(&tr_list);
1309 : }
1310 1 : END_TEST
1311 :
1312 : /* ------------------------------------------------------------------------- */
1313 :
1314 1 : START_TEST(test_result_create_printout_data)
1315 : {
1316 : test_result_printout_s* tr_printout[2];
1317 1 : int TEST_PRIORITY = 10;
1318 1 : char* EMPTY_PRINTOUT = NULL;
1319 1 : char TEST_PRINTOUT[] = "This is a test prinout...";
1320 1 : int result = 0;
1321 :
1322 1 : tr_printout[0] = NULL;
1323 :
1324 1 : tr_printout[0] = tr_create_printout(TEST_PRIORITY, EMPTY_PRINTOUT);
1325 1 : fail_unless(tr_printout[0] != NULL,
1326 : "failed to create Test Result Prinout data structure");
1327 1 : fail_unless(tr_printout[0]->printout_ == NULL,
1328 : "failed to set NULL printout string to printout data");
1329 :
1330 1 : tr_printout[1] = NULL;
1331 1 : tr_printout[1] = tr_create_printout(TEST_PRIORITY, TEST_PRINTOUT);
1332 1 : fail_unless(tr_printout[1] != NULL,
1333 : "failed to create Test Result Prinout data structure");
1334 1 : fail_unless(tr_printout[1]->printout_ != NULL,
1335 : "failed to set example printout string to printout data");
1336 1 : fail_unless(tr_printout[1]->priority_ == TEST_PRIORITY,
1337 : "failed to check that priority data is setting correctly");
1338 :
1339 1 : result = strncmp(tr_printout[1]->printout_, TEST_PRINTOUT,
1340 : strlen(tr_printout[1]->printout_));
1341 1 : fail_unless(result == 0,
1342 : "failed to check that printout data is setting correctly");
1343 :
1344 1 : tr_remove_printout(tr_printout[0]);
1345 1 : tr_remove_printout(tr_printout[1]);
1346 : }
1347 1 : END_TEST
1348 :
1349 : /* ------------------------------------------------------------------------- */
1350 :
1351 1 : START_TEST(test_result_set_and_get_printouts_list)
1352 : {
1353 1 : DLList* tr_list = INITPTR;
1354 1 : DLListIterator tr_data_item = INITPTR;
1355 1 : test_result_s* test_result = NULL;
1356 1 : DLListIterator TEST_CASE_NULL = INITPTR;
1357 :
1358 1 : DLList* printouts_list = INITPTR;
1359 : test_result_printout_s* tr_printout[10];
1360 1 : int TEST_PRIORITY = 10;
1361 1 : char TEST_PRINTOUT[] = "This is a test prinout...";
1362 1 : DLList* check_list = INITPTR;
1363 1 : int result = 0;
1364 : int i;
1365 :
1366 1 : tr_list = dl_list_create();
1367 1 : fail_unless(tr_list != INITPTR, "failed to create list");
1368 :
1369 1 : test_result = tr_create_data_item(TEST_CASE_NULL);
1370 1 : fail_unless(test_result != NULL,
1371 : "failed to create Test Result data structure");
1372 :
1373 1 : tr_data_item = tr_add(tr_list, test_result);
1374 1 : fail_unless(tr_list != INITPTR,
1375 : "failed to add Test Result data item to list");
1376 :
1377 1 : printouts_list = dl_list_create();
1378 1 : fail_unless(printouts_list != INITPTR, "failed to create list");
1379 :
1380 11 : for (i=0; i<10; i++) {
1381 10 : tr_printout[i] = tr_create_printout(TEST_PRIORITY,
1382 : TEST_PRINTOUT);
1383 10 : fail_unless(tr_printout[i] != NULL,
1384 : "failed to create Test Result Prinout data structure");
1385 10 : fail_unless(tr_printout[i]->printout_ != NULL,
1386 : "failed to set example printout string to printout data");
1387 10 : fail_unless(tr_printout[i]->priority_ == TEST_PRIORITY,
1388 : "failed to check that priority data is setting correctly");
1389 :
1390 10 : result = dl_list_add(printouts_list, tr_printout[i]);
1391 10 : fail_unless(result == 0,
1392 : "failed to add Printouts data to linked list");
1393 : }
1394 :
1395 1 : tr_set_priontouts_list(tr_data_item, printouts_list);
1396 1 : check_list = tr_get_priontouts_list(tr_data_item);
1397 1 : fail_unless(check_list == printouts_list,
1398 : "failed to set Printouts List pointer to data item");
1399 :
1400 1 : tr_remove_printouts_list(tr_data_item);
1401 1 : fail_unless(test_result->printouts_list_ == INITPTR,
1402 : "failed to remove Printouts List data in Test Result data");
1403 :
1404 1 : tr_remove(tr_data_item);
1405 :
1406 : }
1407 1 : END_TEST
1408 :
1409 : /* ------------------------------------------------------------------------- */
1410 :
1411 : /* ================= DATA API SUITE FUNCTION =============================== */
1412 :
1413 : Suite *data_api_suite(void)
1414 37 : {
1415 37 : Suite *s = suite_create("data_api");
1416 :
1417 : /* Core test case */
1418 37 : TCase *tc_core = tcase_create("Core");
1419 :
1420 : /* Test Module Info API tests */
1421 37 : tcase_add_test(tc_core, test_module_info_add_to_list);
1422 37 : tcase_add_test(tc_core, test_module_info_set_pid);
1423 37 : tcase_add_test(tc_core, test_module_info_remove_from_list);
1424 37 : tcase_add_test(tc_core, test_module_info_delete_data);
1425 :
1426 : /* Test Module Info data tests */
1427 37 : tcase_add_test(tc_core, test_module_info_get_ptr_by_pid);
1428 37 : tcase_add_test(tc_core, test_module_info_set_and_get_module_filename);
1429 37 : tcase_add_test(tc_core, test_module_info_set_and_get_cfg_filename_list);
1430 37 : tcase_add_test(tc_core, test_module_info_set_and_get_tclist);
1431 37 : tcase_add_test(tc_core, test_module_info_set_and_get_status);
1432 37 : tcase_add_test(tc_core, test_module_info_get_status_without_tm_data);
1433 :
1434 : /* Test Module Info test summary data tests */
1435 37 : tcase_add_test(tc_core, test_module_info_ts_detail_expections);
1436 37 : tcase_add_test(tc_core, test_module_info_get_and_set_ts_details);
1437 37 : tcase_add_test(tc_core, test_module_info_get_test_summary_data);
1438 :
1439 : /* Test Case data creating tests */
1440 37 : tcase_add_test(tc_core, test_case_create_data_item);
1441 37 : tcase_add_test(tc_core, test_case_add_to_list);
1442 37 : tcase_add_test(tc_core, test_case_remove_from_list);
1443 37 : tcase_add_test(tc_core, test_case_delete_data);
1444 :
1445 : /* Test Case function parameter tests */
1446 37 : tcase_add_test(tc_core, test_case_title_under_size_limit);
1447 37 : tcase_add_test(tc_core, test_case_title_over_size_limit);
1448 :
1449 : /* Test Case data tests */
1450 37 : tcase_add_test(tc_core, test_case_set_and_get_test_module_ptr);
1451 37 : tcase_add_test(tc_core, test_case_set_and_get_config_filename);
1452 37 : tcase_add_test(tc_core, test_case_set_and_get_tc_id);
1453 37 : tcase_add_test(tc_core, test_case_set_and_get_tc_group_id);
1454 37 : tcase_add_test(tc_core, test_case_set_and_get_tc_title);
1455 37 : tcase_add_test(tc_core, test_case_set_and_get_status);
1456 37 : tcase_add_test(tc_core, test_case_set_and_get_tc_priority);
1457 37 : tcase_add_test(tc_core, test_case_set_and_get_tr_list);
1458 :
1459 : /* Test Result API tests */
1460 37 : tcase_add_test(tc_core, test_result_create_tr_data_structure);
1461 37 : tcase_add_test(tc_core, test_result_add_tr_data_item);
1462 37 : tcase_add_test(tc_core, test_result_remove_tr_data_item);
1463 :
1464 : /* Test Result data tests */
1465 37 : tcase_add_test(tc_core, test_result_start_and_end_time_data_use);
1466 37 : tcase_add_test(tc_core, test_result_set_and_get_result_type);
1467 37 : tcase_add_test(tc_core, test_result_set_and_get_result_code);
1468 37 : tcase_add_test(tc_core, test_result_set_and_get_result_description);
1469 :
1470 : /* Test Result Printout data tests */
1471 37 : tcase_add_test(tc_core, test_result_create_printout_data);
1472 37 : tcase_add_test(tc_core, test_result_set_and_get_printouts_list);
1473 :
1474 37 : suite_add_tcase (s, tc_core);
1475 :
1476 37 : return s;
1477 : }
|
