1 : /*
2 : * This file is part of MIN Test Framework. Copyright © 2008 Nokia Corporation
3 : * and/or its subsidiary(-ies).
4 : * Contact: Robert Galkowski
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 mintfwif.test
22 : * @version 0.1
23 : * @brief This file contains check tests for mintfwif
24 : */
25 :
26 : /* ------------------------------------------------------------------------- */
27 : /* INCLUDES */
28 : #include <check.h>
29 : #include <mintfwif.h>
30 : #include <tec.h>
31 : #include <min_engine_api.h>
32 :
33 : /* ------------------------------------------------------------------------- */
34 : /* CONSTANTS */
35 : /* None */
36 :
37 : /* ------------------------------------------------------------------------- */
38 : /* MACROS */
39 : /* None */
40 :
41 : /* ------------------------------------------------------------------------- */
42 : /* DATA TYPES */
43 : eapiIn_t in_str;
44 : eapiOut_t out_str;
45 :
46 : /* ------------------------------------------------------------------------- */
47 : /* LOCAL FUNCTION PROTOTYPES */
48 : /* None */
49 :
50 : /* ------------------------------------------------------------------------- */
51 : /* FORWARD DECLARATIONS */
52 : /* None */
53 :
54 : /* ------------------------------------------------------------------------- */
55 : /* STRUCTURES */
56 : char **envp_;
57 :
58 : /* ------------------------------------------------------------------------- */
59 : /* ==================== LOCAL FUNCTIONS ==================================== */
60 : LOCAL void emptycallback1 (int run_id, int execution_result, int test_result, char *desc)
61 5 : {
62 : return;
63 : }
64 : LOCAL void emptycallback2 (int run_id, char *text)
65 4 : {
66 : return;
67 : }
68 :
69 : LOCAL void emptycallback3(char* text,int len)
70 0 : {
71 : return;
72 : }
73 :
74 : void setup (void)
75 16 : {
76 16 : min_if_open (emptycallback1,emptycallback2,emptycallback3,NULL,envp_);
77 16 : }
78 :
79 : void teardown (void)
80 16 : {
81 16 : min_if_close();
82 :
83 16 : }
84 :
85 : /* ------------------------------------------------------------------------- */
86 : /* ============================= TESTS ===================================== */
87 : /* ------------------------------------------------------------------------- */
88 :
89 1 : START_TEST(exec_case_inv_arg)
90 : {
91 1 : int result = min_if_exec_case("DemoTestModule.so",0);
92 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
93 : }
94 1 : END_TEST
95 : /* ------------------------------------------------------------------------- */
96 1 : START_TEST(module_add_fail)
97 : {
98 1 : int result = min_if_module_add ("_should_not_exist_", "");
99 1 : fail_if( result == 0 ,"wrong return value: %d",result);
100 :
101 : }
102 1 : END_TEST
103 : /* ------------------------------------------------------------------------- */
104 1 : START_TEST(cancel_case_inv_arg)
105 : {
106 1 : DLListIterator work_module_item = DLListNULLIterator;
107 : int status;
108 1 : int cont_flag = 0;
109 1 : DLListIterator work_case_item = DLListNULLIterator;
110 1 : int result = 0;
111 1 : ec_min_init(envp_,0);
112 1 : ec_configure();
113 1 : ec_start_modules();
114 :
115 4 : while( cont_flag == 0 ) {
116 2 : usleep(100000);
117 2 : work_module_item = dl_list_head(instantiated_modules);
118 10 : while( work_module_item != DLListNULLIterator ) {
119 6 : status = tm_get_status(work_module_item);
120 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
121 3 : else cont_flag = 0;
122 6 : work_module_item = dl_list_next(work_module_item);
123 : }
124 : }
125 :
126 1 : work_module_item = dl_list_head( instantiated_modules );
127 1 : work_case_item = dl_list_head(tm_get_tclist(work_module_item));
128 1 : ec_exec_test_case(work_case_item);
129 1 : result = min_if_cancel_case (7);
130 1 : usleep(200000);
131 1 : ec_cleanup();
132 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
133 : }
134 1 : END_TEST
135 : /* ------------------------------------------------------------------------- */
136 1 : START_TEST(cancel_case_not_running)
137 : {
138 :
139 1 : DLListIterator work_module_item = DLListNULLIterator;
140 : int status;
141 1 : int cont_flag = 0;
142 1 : DLListIterator work_case_item = DLListNULLIterator;
143 1 : int result = 0;
144 :
145 1 : ec_min_init(envp_,0);
146 1 : ec_configure();
147 1 : ec_start_modules();
148 :
149 4 : while( cont_flag == 0 ) {
150 2 : usleep(100000);
151 2 : work_module_item = dl_list_head(instantiated_modules);
152 10 : while( work_module_item != DLListNULLIterator ) {
153 6 : status = tm_get_status(work_module_item);
154 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
155 3 : else cont_flag = 0;
156 6 : work_module_item = dl_list_next(work_module_item);
157 : }
158 : }
159 :
160 1 : work_module_item = dl_list_head( instantiated_modules );
161 1 : work_case_item = dl_list_head(tm_get_tclist(work_module_item));
162 1 : ec_exec_test_case ( work_case_item );
163 1 : usleep(500000);
164 1 : result = min_if_cancel_case(0);
165 :
166 1 : ec_cleanup();
167 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
168 :
169 : }
170 1 : END_TEST
171 : /* ------------------------------------------------------------------------- */
172 1 : START_TEST(cancel_case_cancelled)
173 : {
174 :
175 1 : DLListIterator work_module_item = DLListNULLIterator;
176 : int status;
177 1 : int cont_flag = 0;
178 1 : DLListIterator work_case_item = DLListNULLIterator;
179 1 : int result = 0;
180 :
181 1 : ec_min_init(envp_,0);
182 1 : ec_configure();
183 1 : ec_start_modules();
184 :
185 4 : while( cont_flag == 0 ) {
186 2 : usleep(100000);
187 2 : work_module_item = dl_list_head(instantiated_modules);
188 10 : while( work_module_item != DLListNULLIterator ) {
189 6 : status = tm_get_status(work_module_item);
190 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
191 3 : else cont_flag = 0;
192 6 : work_module_item = dl_list_next(work_module_item);
193 : }
194 : }
195 :
196 1 : work_module_item = dl_list_head( instantiated_modules );
197 1 : work_case_item = dl_list_at(tm_get_tclist(work_module_item),1);
198 1 : ec_exec_test_case ( work_case_item );
199 1 : usleep(200000);
200 1 : work_case_item = dl_list_at(selected_cases,0);
201 :
202 1 : ec_abort_test_case(work_case_item);
203 1 : usleep(200000);
204 1 : result = min_if_cancel_case(0);
205 :
206 1 : usleep(200000);
207 1 : fail_unless ( (tc_get_status(work_case_item)) == TEST_CASE_TERMINATED , "Case status changed");
208 :
209 1 : ec_cleanup();
210 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
211 :
212 : }
213 1 : END_TEST
214 : /* ------------------------------------------------------------------------- */
215 1 : START_TEST(cancel_case_success)
216 : {
217 1 : unsigned int result = 0;
218 :
219 1 : result = min_if_module_add ("minDemoModule", "");
220 :
221 1 : result = min_if_exec_case ("minDemoModule", 2);
222 :
223 1 : result = min_if_cancel_case (result);
224 1 : fail_unless ( result == 0, "Cancel case failed");
225 :
226 : }
227 1 : END_TEST
228 : /* ------------------------------------------------------------------------- */
229 1 : START_TEST(pause_case_inv_arg)
230 : {
231 :
232 1 : DLListIterator work_module_item = DLListNULLIterator;
233 : int status;
234 1 : int cont_flag = 0;
235 1 : DLListIterator work_case_item = DLListNULLIterator;
236 1 : int result = 0;
237 1 : ec_min_init(envp_,0);
238 1 : ec_configure();
239 1 : ec_start_modules();
240 :
241 4 : while( cont_flag == 0 ) {
242 2 : usleep(100000);
243 2 : work_module_item = dl_list_head(instantiated_modules);
244 10 : while( work_module_item != DLListNULLIterator ) {
245 6 : status = tm_get_status(work_module_item);
246 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
247 3 : else cont_flag = 0;
248 6 : work_module_item = dl_list_next(work_module_item);
249 : }
250 : }
251 :
252 1 : work_module_item = dl_list_head( instantiated_modules );
253 1 : work_case_item = dl_list_head(tm_get_tclist(work_module_item));
254 1 : ec_exec_test_case(work_case_item);
255 1 : result = min_if_pause_case (7);
256 1 : ec_cleanup();
257 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
258 :
259 : }
260 1 : END_TEST
261 : /* ------------------------------------------------------------------------- */
262 1 : START_TEST(pause_case_not_running)
263 : {
264 :
265 1 : DLListIterator work_module_item = DLListNULLIterator;
266 : int status;
267 1 : int cont_flag = 0;
268 1 : DLListIterator work_case_item = DLListNULLIterator;
269 1 : int result = 0;
270 :
271 1 : ec_min_init(envp_,0);
272 1 : ec_configure();
273 1 : ec_start_modules();
274 :
275 4 : while( cont_flag == 0 ) {
276 2 : usleep(100000);
277 2 : work_module_item = dl_list_head(instantiated_modules);
278 10 : while( work_module_item != DLListNULLIterator ) {
279 6 : status = tm_get_status(work_module_item);
280 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
281 3 : else cont_flag = 0;
282 6 : work_module_item = dl_list_next(work_module_item);
283 : }
284 : }
285 :
286 1 : work_module_item = dl_list_head( instantiated_modules );
287 1 : work_case_item = dl_list_head(tm_get_tclist(work_module_item));
288 1 : ec_exec_test_case ( work_case_item );
289 1 : usleep(500000);
290 1 : result = min_if_pause_case (0);
291 :
292 1 : ec_cleanup();
293 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
294 :
295 : }
296 1 : END_TEST
297 : /* ------------------------------------------------------------------------- */
298 1 : START_TEST(pause_case_paused)
299 : {
300 :
301 1 : DLListIterator work_module_item = DLListNULLIterator;
302 : int status;
303 1 : int cont_flag = 0;
304 1 : DLListIterator work_case_item = DLListNULLIterator;
305 1 : int result = 0;
306 :
307 1 : ec_min_init(envp_,0);
308 1 : ec_configure();
309 1 : ec_start_modules();
310 :
311 4 : while( cont_flag == 0 ) {
312 2 : usleep(100000);
313 2 : work_module_item = dl_list_head(instantiated_modules);
314 10 : while( work_module_item != DLListNULLIterator ) {
315 6 : status = tm_get_status(work_module_item);
316 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
317 3 : else cont_flag = 0;
318 6 : work_module_item = dl_list_next(work_module_item);
319 : }
320 : }
321 :
322 1 : work_module_item = dl_list_head( instantiated_modules );
323 1 : work_case_item = dl_list_at(tm_get_tclist(work_module_item),1);
324 1 : ec_exec_test_case ( work_case_item );
325 1 : usleep(200000);
326 1 : work_case_item = dl_list_at(selected_cases,0);
327 :
328 1 : ec_pause_test_case(work_case_item);
329 1 : result = min_if_pause_case (0);
330 :
331 :
332 1 : usleep(200000);
333 1 : fail_unless ( (tc_get_status(work_case_item)) == TEST_CASE_PAUSED , "Case status changed");
334 :
335 1 : ec_cleanup();
336 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
337 :
338 : }
339 1 : END_TEST
340 : /* ------------------------------------------------------------------------- */
341 1 : START_TEST(pause_case_success)
342 : {
343 1 : unsigned int result = 0;
344 :
345 1 : result = min_if_module_add ("minDemoModule", "");
346 :
347 1 : result = min_if_exec_case ("minDemoModule", 2);
348 :
349 1 : result = min_if_pause_case (result);
350 1 : fail_unless ( result == 0, "pause case failed");
351 :
352 : }
353 1 : END_TEST
354 : /* ------------------------------------------------------------------------- */
355 1 : START_TEST(resume_case_inv_arg)
356 : {
357 :
358 1 : DLListIterator work_module_item = DLListNULLIterator;
359 : int status;
360 1 : int cont_flag = 0;
361 1 : DLListIterator work_case_item = DLListNULLIterator;
362 1 : int result = 0;
363 1 : ec_min_init(envp_,0);
364 1 : ec_configure();
365 1 : ec_start_modules();
366 :
367 4 : while( cont_flag == 0 ) {
368 2 : usleep(100000);
369 2 : work_module_item = dl_list_head(instantiated_modules);
370 10 : while( work_module_item != DLListNULLIterator ) {
371 6 : status = tm_get_status(work_module_item);
372 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
373 3 : else cont_flag = 0;
374 6 : work_module_item = dl_list_next(work_module_item);
375 : }
376 : }
377 :
378 1 : work_module_item = dl_list_head( instantiated_modules );
379 1 : work_case_item = dl_list_head(tm_get_tclist(work_module_item));
380 1 : ec_exec_test_case(work_case_item);
381 1 : result = min_if_resume_case (7);
382 1 : ec_cleanup();
383 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
384 :
385 : }
386 1 : END_TEST
387 : /* ------------------------------------------------------------------------- */
388 1 : START_TEST(resume_case_not_paused)
389 : {
390 :
391 1 : DLListIterator work_module_item = DLListNULLIterator;
392 : int status;
393 1 : int cont_flag = 0;
394 1 : DLListIterator work_case_item = DLListNULLIterator;
395 1 : int result = 0;
396 1 : ec_min_init(envp_,0);
397 1 : ec_configure();
398 1 : ec_start_modules();
399 :
400 4 : while( cont_flag == 0 ) {
401 2 : usleep(100000);
402 2 : work_module_item = dl_list_head(instantiated_modules);
403 10 : while( work_module_item != DLListNULLIterator ) {
404 6 : status = tm_get_status(work_module_item);
405 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
406 3 : else cont_flag = 0;
407 6 : work_module_item = dl_list_next(work_module_item);
408 : }
409 : }
410 :
411 1 : work_module_item = dl_list_head( instantiated_modules );
412 1 : work_case_item = dl_list_at ( tm_get_tclist ( work_module_item ) , 1 );
413 1 : ec_exec_test_case(work_case_item);
414 1 : result = min_if_resume_case ( 0 );
415 :
416 1 : ec_cleanup();
417 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
418 :
419 : }
420 1 : END_TEST
421 : /* ------------------------------------------------------------------------- */
422 1 : START_TEST(resume_case_paused)
423 : {
424 1 : unsigned int result = 0, run_id;
425 :
426 1 : result = min_if_module_add ("minDemoModule", "");
427 :
428 1 : run_id = min_if_exec_case ("minDemoModule", 2);
429 :
430 1 : result = min_if_pause_case (run_id);
431 1 : fail_unless ( result == 0, "pause case failed");
432 :
433 1 : result = min_if_resume_case (run_id);
434 1 : fail_unless ( result == 0, "resume case failed");
435 :
436 : }
437 1 : END_TEST
438 : /* ------------------------------------------------------------------------- */
439 1 : START_TEST(resume_case_not_running)
440 : {
441 :
442 1 : DLListIterator work_module_item = DLListNULLIterator;
443 : int status;
444 1 : int cont_flag = 0;
445 1 : DLListIterator work_case_item = DLListNULLIterator;
446 1 : int result = 0;
447 :
448 1 : ec_min_init(envp_,0);
449 1 : ec_configure();
450 1 : ec_start_modules();
451 :
452 4 : while( cont_flag == 0 ) {
453 2 : usleep(100000);
454 2 : work_module_item = dl_list_head(instantiated_modules);
455 10 : while( work_module_item != DLListNULLIterator ) {
456 6 : status = tm_get_status(work_module_item);
457 6 : if (status == TEST_MODULE_READY) cont_flag = cont_flag | 1;
458 3 : else cont_flag = 0;
459 6 : work_module_item = dl_list_next(work_module_item);
460 : }
461 : }
462 :
463 1 : work_module_item = dl_list_head( instantiated_modules );
464 1 : work_case_item = dl_list_head(tm_get_tclist(work_module_item));
465 1 : ec_exec_test_case ( work_case_item );
466 1 : usleep(500000);
467 1 : result = min_if_resume_case (0);
468 :
469 1 : ec_cleanup();
470 1 : fail_unless( result == 1 ,"wrong return value: %d",result);
471 :
472 : }
473 1 : END_TEST
474 : /* ------------------------------------------------------------------------- */
475 1 : START_TEST(get_cases_success)
476 : {
477 1 : int result = 0;
478 : module_info* av_mods;
479 1 : int cont_flag = 0;
480 1 : DLListIterator work_case_item = DLListNULLIterator;
481 1 : DLListIterator work_module_item = DLListNULLIterator;
482 : int status;
483 :
484 1 : result = min_if_module_add ("minDemoModule", "");
485 1 : fail_unless(result == 0 ,"Module add failed");
486 1 : result = min_if_get_cases (&av_mods);
487 1 : fail_unless(result == 1, "wrong number of modules");
488 :
489 1 : fail_if(strstr(av_mods[0].module_name_,"minDemoModule") == NULL,
490 : "Wrong module name");
491 1 : fail_unless(av_mods[0].num_test_cases_ == 4,
492 : "Wrong number of test cases %d",
493 : av_mods[0].num_test_cases_);
494 1 : fail_unless(strcmp(av_mods[0].test_cases_[0].case_name_,
495 : "Demo_1") == 0,"Wrong case title");
496 1 : fail_unless(av_mods[0].test_cases_[0].case_id_ == 1,
497 : "wrong case id, %d",av_mods[0].test_cases_[0].case_id_);
498 1 : fail_unless(strcmp(av_mods[0].test_cases_[1].case_name_,
499 : "Demo_2") == 0,"Wrong case title");
500 1 : fail_unless(av_mods[0].test_cases_[1].case_id_ == 2,
501 : "wrong case id, %d",av_mods[0].test_cases_[1].case_id_);
502 : }
503 1 : END_TEST
504 : /* ------------------------------------------------------------------------- */
505 1 : START_TEST(add_module_without_tcfile)
506 : {
507 1 : int result = min_if_module_add ("minDemoModule", "");
508 1 : fail_unless( result == 0 ,"wrong return value: %d",result);
509 :
510 : }
511 1 : END_TEST
512 :
513 : /* ------------------------------------------------------------------------- */
514 : /* ========================== FUNCTIONS ==================================== */
515 : /* ------------------------------------------------------------------------- */
516 : Suite* mintfwif_suite()
517 17 : {
518 17 : Suite * s = suite_create ("mintfwif");
519 :
520 : /* Core test case */
521 17 : TCase *tc_core = tcase_create ("Core");
522 17 : tcase_add_checked_fixture (tc_core, setup, teardown);
523 :
524 17 : tcase_add_test ( tc_core, module_add_fail );
525 :
526 17 : tcase_add_test ( tc_core, exec_case_inv_arg );
527 17 : tcase_add_test ( tc_core, cancel_case_inv_arg );
528 17 : tcase_add_test ( tc_core, cancel_case_not_running );
529 17 : tcase_add_test ( tc_core, cancel_case_success );
530 17 : tcase_add_test ( tc_core, cancel_case_cancelled );
531 17 : tcase_add_test ( tc_core, pause_case_inv_arg );
532 17 : tcase_add_test ( tc_core, pause_case_not_running );
533 17 : tcase_add_test ( tc_core, pause_case_success );
534 17 : tcase_add_test ( tc_core, pause_case_paused );
535 17 : tcase_add_test ( tc_core, resume_case_inv_arg );
536 17 : tcase_add_test ( tc_core, resume_case_not_paused );
537 17 : tcase_add_test ( tc_core, resume_case_paused );
538 17 : tcase_add_test ( tc_core, resume_case_not_running );
539 17 : tcase_add_test ( tc_core, get_cases_success );
540 17 : tcase_add_test ( tc_core, add_module_without_tcfile );
541 17 : tcase_set_timeout ( tc_core, 10);
542 17 : suite_add_tcase (s, tc_core);
543 :
544 17 : return s;
545 : }
546 :
547 : int mintfwif_tests(char *envp[])
548 17 : {
549 : int number_failed;
550 : Suite * s;
551 : SRunner * sr;
552 17 : envp_ = envp;
553 17 : number_failed = 0;
554 17 : s = mintfwif_suite ();
555 17 : sr = srunner_create (s);
556 :
557 : // srunner_set_fork_status (sr,CK_NOFORK);
558 17 : srunner_run_all(sr, CK_NORMAL);
559 1 : number_failed = srunner_ntests_failed(sr);
560 1 : srunner_free(sr);
561 1 : return number_failed;
562 : }
563 :
564 :
565 :
566 : /* ------------------------------------------------------------------------- */
567 : /* ------------------------------------------------------------------------- */
568 : /* End of file */
|
