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.c
22 : * @version 0.1
23 : * @brief This file contains implementation of mintfwif
24 : */
25 :
26 : /* ------------------------------------------------------------------------- */
27 : /* INCLUDE FILES */
28 : #include <ctype.h>
29 : #include <string.h>
30 : #include <tec.h>
31 : #include <data_api.h>
32 : #include <mintfwif.h>
33 : #include <min_engine_api.h>
34 : #include <tmc_common.h>
35 : #include <dllist.h>
36 :
37 : /* ------------------------------------------------------------------------- */
38 : /* EXTERNAL DATA STRUCTURES */
39 : /* None */
40 :
41 : /* ------------------------------------------------------------------------- */
42 : /* EXTERNAL GLOBAL VARIABLES */
43 :
44 : /* ------------------------------------------------------------------------- */
45 : /* EXTERNAL FUNCTION PROTOTYPES */
46 :
47 : extern char *strcasestr (const char *haystack, const char *needle);
48 : extern eapiIn_t in_str;
49 :
50 :
51 :
52 : /* ------------------------------------------------------------------------- */
53 : /* MODULE DATA STRUCTURES */
54 : typedef struct {
55 : char module_name_[128];
56 : DLList *test_case_list_;
57 : unsigned module_id_;
58 : int module_ready_;
59 : } internal_module_info;
60 :
61 :
62 : /** Structure for storage of executed test case data*/
63 : typedef struct {
64 : /** Test Case ID */
65 : unsigned int case_id_;
66 : /** Module ID */
67 : unsigned int module_id_;
68 : /** Test run ID */
69 : unsigned int test_run_id_;
70 : /** Test run status */
71 : MINTPStatus status_;
72 : /** Test run group ID */
73 : unsigned int group_id_;
74 : } internal_test_run_info;
75 :
76 :
77 : /* ------------------------------------------------------------------------- */
78 : /* GLOBAL VARIABLES */
79 : /* module list */
80 : DLList *tfwif_modules_ = INITPTR;
81 : DLList *tfwif_test_runs_ = INITPTR;
82 : /* number of ready modules */
83 : unsigned ready_module_count_ = 0;
84 : pthread_mutex_t tfwif_mutex_ = PTHREAD_MUTEX_INITIALIZER;
85 : tfwif_callbacks_s tfwif_callbacks;
86 :
87 : /* ------------------------------------------------------------------------- */
88 : /* CONSTANTS */
89 : /* None */
90 :
91 : /* ------------------------------------------------------------------------- */
92 : /* MACROS */
93 : /* None */
94 :
95 : /* ------------------------------------------------------------------------- */
96 : /* LOCAL GLOBAL VARIABLES */
97 :
98 : int already_executed = 0;
99 : eapiOut_t min_clbk_;
100 : eapiIn_t *in;
101 : /* ------------------------------------------------------------------------- */
102 : /* LOCAL CONSTANTS AND MACROS */
103 : /* None */
104 : /* ------------------------------------------------------------------------- */
105 : /* LOCAL FUNCTION PROTOTYPES */
106 : /* None */
107 :
108 : LOCAL void pl_case_result (long testrunid, int result, char *desc,
109 : long starttime, long endtime);
110 : /* ------------------------------------------------------------------------- */
111 : LOCAL void pl_case_started (unsigned moduleid,
112 : unsigned caseid,
113 : long testrunid);
114 : /* ------------------------------------------------------------------------- */
115 : LOCAL void pl_case_paused (long testrunid);
116 : /* ------------------------------------------------------------------------- */
117 : LOCAL void pl_case_resumed (long testrunid);
118 : /* ------------------------------------------------------------------------- */
119 : LOCAL void pl_msg_print (long testrunid, char *message);
120 : /* ------------------------------------------------------------------------- */
121 : LOCAL void pl_new_module (char *modulename, unsigned moduleid);
122 : /* ------------------------------------------------------------------------- */
123 : LOCAL void pl_module_ready (unsigned moduleid);
124 : /* ------------------------------------------------------------------------- */
125 : LOCAL void pl_no_module (char *modulename);
126 : /* ------------------------------------------------------------------------- */
127 : LOCAL void pl_new_case (unsigned moduleid, unsigned caseid, char *casetitle);
128 : /* ------------------------------------------------------------------------- */
129 : LOCAL void pl_error_report (char *error);
130 : /* ------------------------------------------------------------------------- */
131 : LOCAL void pl_send_rcp (char *cmd, char *sender, char *rcvr, char* msg,
132 : int param);
133 : /* ------------------------------------------------------------------------- */
134 : LOCAL int _find_mod_by_id (const void *a, const void *b);
135 : /* ------------------------------------------------------------------------- */
136 : LOCAL int _find_testrun_by_id (const void *a, const void *b);
137 : /* ------------------------------------------------------------------------- */
138 : LOCAL int _find_mod_by_name (const void *a, const void *b);
139 : /* ------------------------------------------------------------------------- */
140 : LOCAL void _del_internal_mod_info (void *data);
141 : /* ------------------------------------------------------------------------- */
142 : /* FORWARD DECLARATIONS */
143 : void pl_attach_plugin (eapiIn_t **out_callback, eapiOut_t *in_callback);
144 :
145 : /* ==================== LOCAL FUNCTIONS ==================================== */
146 : /* None */
147 : /* ======================== FUNCTIONS ====================================== */
148 : /* ------------------------------------------------------------------------- */
149 : int min_if_set_device_id (int device_id)
150 3 : {
151 3 : own_id = device_id;
152 3 : return 0;
153 : }
154 :
155 : /* ------------------------------------------------------------------------- */
156 :
157 :
158 : int min_if_open (min_case_complete_func complete_cb,
159 : min_case_print_func print_cb,
160 : min_extif_message_cb_ extifsend_cb, char *engine_ini,
161 : char *envp[])
162 37 : {
163 : int module_count;
164 :
165 37 : tfwif_callbacks.complete_callback_ = complete_cb;
166 37 : tfwif_callbacks.print_callback_ = print_cb;
167 37 : tfwif_callbacks.send_extif_msg_ = extifsend_cb;
168 :
169 37 : if (tfwif_modules_ == INITPTR)
170 37 : tfwif_modules_ = dl_list_create();
171 :
172 37 : if (!already_executed) {
173 37 : in = &in_str;
174 37 : eapi_init (in, &min_clbk_);
175 : }
176 37 : pl_attach_plugin (&in, &min_clbk_);
177 37 : ec_min_init (envp, 1);
178 37 : already_executed++;
179 :
180 37 : module_count = min_clbk_.min_open();
181 74 : while (module_count > ready_module_count_) {
182 0 : usleep (50000);
183 : }
184 37 : usleep (500000);
185 37 : if ((engine_ini != NULL) && (strlen (engine_ini) != 0)) {
186 0 : ec_read_settings (engine_ini);
187 :
188 : }
189 :
190 37 : return 0;
191 : }
192 :
193 : /* ------------------------------------------------------------------------- */
194 : int min_if_close ()
195 24 : {
196 : /*
197 : ** Clear lists
198 : */
199 24 : dl_list_foreach (dl_list_head (tfwif_modules_),
200 : dl_list_tail (tfwif_modules_),
201 : _del_internal_mod_info);
202 24 : dl_list_free (&tfwif_modules_);
203 24 : dl_list_foreach (dl_list_head (tfwif_test_runs_),
204 : dl_list_tail (tfwif_test_runs_),
205 : free);
206 24 : dl_list_free (&tfwif_test_runs_);
207 :
208 24 : if(min_clbk_.min_close) {
209 24 : min_clbk_.min_close();
210 : }
211 :
212 24 : MIN_DEBUG ("MODULES FREED");
213 24 : ready_module_count_ = 0;
214 24 : usleep (500000);
215 :
216 24 : return 0;
217 : }
218 :
219 :
220 : /* ------------------------------------------------------------------------- */
221 : int min_if_message_received (char *message, int length)
222 7 : {
223 7 : if(min_clbk_.receive_rcp) {
224 7 : return min_clbk_.receive_rcp(message, length);
225 : }
226 :
227 :
228 0 : return 1;
229 : }
230 :
231 : /* ------------------------------------------------------------------------- */
232 : int min_if_exec_case (char *module, unsigned int id)
233 22 : {
234 : internal_module_info *mi;
235 22 : internal_test_run_info *tri = INITPTR;
236 :
237 : DLListIterator it;
238 22 : int cont = 1;
239 22 : pthread_mutex_lock (&tfwif_mutex_);
240 22 : it = dl_list_find (dl_list_head (tfwif_modules_),
241 : dl_list_tail (tfwif_modules_),
242 : _find_mod_by_name,
243 : (const void *)module);
244 22 : pthread_mutex_unlock (&tfwif_mutex_);
245 :
246 22 : if (it == INITPTR)
247 1 : return 1;
248 :
249 21 : mi = dl_list_data (it);
250 :
251 21 : if (!min_clbk_.start_case (mi->module_id_, id, 0)) {
252 265 : while (cont) {
253 229 : usleep (10000);
254 229 : pthread_mutex_lock (&tfwif_mutex_);
255 229 : for (it = dl_list_head (tfwif_test_runs_);
256 520 : it != INITPTR;
257 62 : it = dl_list_next (it)) {
258 80 : tri = dl_list_data (it);
259 80 : if (tri->module_id_ != mi->module_id_)
260 0 : continue;
261 80 : if (tri->status_ != TP_RUNNING)
262 0 : continue;
263 80 : if (tri->case_id_ != id)
264 62 : continue;
265 : /* we found the just started test case */
266 18 : cont = 0;
267 18 : break;
268 :
269 : }
270 229 : pthread_mutex_unlock (&tfwif_mutex_);
271 :
272 : }
273 : } else
274 0 : return -1;
275 :
276 36 : MIN_DEBUG("test started with runid=%d", tri->test_run_id_);
277 18 : return tri->test_run_id_;
278 : }
279 :
280 : /* ------------------------------------------------------------------------- */
281 : int min_if_cancel_case (unsigned int runtime_id)
282 5 : {
283 : DLListIterator it;
284 :
285 :
286 5 : pthread_mutex_lock (&tfwif_mutex_);
287 5 : it = dl_list_find (dl_list_head (tfwif_test_runs_),
288 : dl_list_tail (tfwif_test_runs_),
289 : _find_testrun_by_id,
290 : (const void *)&runtime_id);
291 5 : pthread_mutex_unlock (&tfwif_mutex_);
292 :
293 5 : if (it == INITPTR)
294 3 : return 1;
295 :
296 2 : return min_clbk_.abort_case (runtime_id);
297 : }
298 :
299 : /* ------------------------------------------------------------------------- */
300 : int min_if_pause_case (unsigned int runtime_id)
301 7 : {
302 : DLListIterator it;
303 :
304 7 : pthread_mutex_lock (&tfwif_mutex_);
305 7 : it = dl_list_find (dl_list_head (tfwif_test_runs_),
306 : dl_list_tail (tfwif_test_runs_),
307 : _find_testrun_by_id,
308 : (const void *)&runtime_id);
309 7 : pthread_mutex_unlock (&tfwif_mutex_);
310 :
311 7 : if (it == INITPTR)
312 3 : return 1;
313 :
314 4 : return min_clbk_.pause_case (runtime_id);
315 : }
316 :
317 : /* ------------------------------------------------------------------------- */
318 :
319 : int min_if_get_cases (module_info ** modules_arg)
320 15 : {
321 :
322 15 : int extif_list_size = 0;
323 15 : DLListIterator mod_it = DLListNULLIterator;
324 15 : DLListIterator case_it = DLListNULLIterator;
325 15 : int i = 0, j, cases_count;
326 15 : module_info *modules = NULL;
327 : internal_module_info *mi;
328 : min_case *mc;
329 :
330 15 : extif_list_size = dl_list_size(tfwif_modules_);
331 15 : modules = NEW2 (module_info, extif_list_size);
332 :
333 15 : pthread_mutex_lock (&tfwif_mutex_);
334 15 : for (mod_it = dl_list_head (tfwif_modules_);
335 73 : mod_it != DLListNULLIterator;
336 43 : mod_it = dl_list_next (mod_it)) {
337 43 : mi = dl_list_data (mod_it);
338 :
339 43 : STRCPY (modules[i].module_name_, mi->module_name_, 128);
340 :
341 43 : cases_count = dl_list_size (mi->test_case_list_);
342 43 : modules[i].num_test_cases_ = cases_count;
343 43 : modules[i].test_cases_ = NEW2 (min_case, cases_count);
344 43 : j = 0;
345 43 : for (case_it = dl_list_head (mi->test_case_list_);
346 230 : case_it != DLListNULLIterator;
347 144 : case_it = dl_list_next (case_it)) {
348 144 : mc = dl_list_data (case_it);
349 144 : modules[i].test_cases_[j] = *mc;
350 144 : j++;
351 : }
352 43 : i ++;
353 : }
354 15 : pthread_mutex_unlock (&tfwif_mutex_);
355 :
356 15 : *modules_arg = modules;
357 15 : MIN_DEBUG ("Number of modules = %d, modules: %x", extif_list_size,
358 : modules);
359 :
360 15 : return extif_list_size;
361 : }
362 :
363 : /* ------------------------------------------------------------------------- */
364 :
365 : int min_if_resume_case (unsigned int runtime_id)
366 5 : {
367 : DLListIterator it;
368 :
369 5 : pthread_mutex_lock (&tfwif_mutex_);
370 5 : it = dl_list_find (dl_list_head (tfwif_test_runs_),
371 : dl_list_tail (tfwif_test_runs_),
372 : _find_testrun_by_id,
373 : (const void *)&runtime_id);
374 5 : pthread_mutex_unlock (&tfwif_mutex_);
375 :
376 5 : if (it == INITPTR)
377 4 : return 1;
378 :
379 1 : return min_clbk_.resume_case (runtime_id);
380 : }
381 :
382 : /* ------------------------------------------------------------------------- */
383 : int min_if_module_add (char *module_name, char *conf_name)
384 69 : {
385 69 : DLListIterator it = INITPTR;
386 : internal_module_info *mi;
387 :
388 69 : MIN_DEBUG ("MODULE:%s, CONFIG:%s", module_name,
389 : conf_name != NULL ? conf_name : "<null>");
390 69 : if (min_clbk_.add_test_module (module_name)) {
391 0 : MIN_WARN ("Returning error");
392 0 : return 1;
393 : }
394 207 : while (it == INITPTR) {
395 :
396 69 : usleep (500000);
397 :
398 69 : pthread_mutex_lock (&tfwif_mutex_);
399 69 : it = dl_list_find (dl_list_head (tfwif_modules_),
400 : dl_list_tail (tfwif_modules_),
401 : _find_mod_by_name,
402 : (const void *)module_name);
403 69 : pthread_mutex_unlock (&tfwif_mutex_);
404 :
405 : }
406 :
407 69 : mi = dl_list_data (it);
408 69 : if (conf_name &&
409 : min_clbk_.add_test_case_file (mi->module_id_, conf_name)) {
410 1 : MIN_WARN ("returning error");
411 1 : return 1;
412 : }
413 68 : min_clbk_.add_test_case_file (mi->module_id_, "");
414 :
415 1801 : while (!mi->module_ready_)
416 1669 : usleep (10000);
417 :
418 66 : if (dl_list_size (mi->test_case_list_) == 0) {
419 : /*
420 : ** Module added succesfully, but does not contain any cases,
421 : ** we can remove it now.
422 : */
423 0 : pthread_mutex_lock (&tfwif_mutex_);
424 0 : dl_list_remove_it (it);
425 0 : _del_internal_mod_info (mi);
426 0 : pthread_mutex_unlock (&tfwif_mutex_);
427 :
428 : }
429 :
430 66 : return 0;
431 : }
432 :
433 :
434 : void pl_attach_plugin (eapiIn_t **out_callback, eapiOut_t *in_callback)
435 37 : {
436 : /* Binds the callbacks */
437 :
438 :
439 37 : (*out_callback)->case_result = pl_case_result;
440 37 : (*out_callback)->case_started = pl_case_started;
441 37 : (*out_callback)->case_paused = pl_case_paused;
442 37 : (*out_callback)->case_resumed = pl_case_resumed;
443 37 : (*out_callback)->module_prints = pl_msg_print;
444 37 : (*out_callback)->new_module = pl_new_module;
445 37 : (*out_callback)->no_module = pl_no_module;
446 37 : (*out_callback)->module_ready = pl_module_ready;
447 37 : (*out_callback)->new_case = pl_new_case;
448 37 : (*out_callback)->error_report = pl_error_report;
449 37 : (*out_callback)->send_rcp = pl_send_rcp;
450 :
451 : return;
452 : }
453 : /* ------------------------------------------------------------------------- */
454 : void pl_open_plugin (void *arg)
455 0 : {
456 : return;
457 : }
458 : /* ------------------------------------------------------------------------- */
459 : void pl_close_plugin ()
460 0 : {
461 : return;
462 : }
463 : /* ------------------------------------------------------------------------- */
464 : void pl_detach_plugin (eapiIn_t **out_callback, eapiOut_t *in_callback)
465 0 : {
466 : return;
467 : }
468 : /* ------------------------------------------------------------------------- */
469 :
470 :
471 : LOCAL void pl_case_result (long testrunid, int result, char *desc,
472 6 : long starttime, long endtime){
473 :
474 :
475 6 : internal_test_run_info *tri = INITPTR;
476 6 : DLListIterator test_run_item = DLListNULLIterator;
477 :
478 6 : pthread_mutex_lock (&tfwif_mutex_);
479 6 : test_run_item = dl_list_find (dl_list_head (tfwif_test_runs_),
480 : dl_list_tail (tfwif_test_runs_),
481 : _find_testrun_by_id,
482 : (const void *)&testrunid);
483 6 : pthread_mutex_unlock (&tfwif_mutex_);
484 :
485 6 : if (test_run_item == DLListNULLIterator) {
486 0 : MIN_WARN ("no matching test run info found testrun id = %d",
487 : testrunid);
488 0 : return;
489 : }
490 6 : tri = dl_list_data (test_run_item);
491 6 : tri->status_ = TP_ENDED;
492 6 : tfwif_callbacks.complete_callback_ (tri->test_run_id_, 1, result, desc);
493 :
494 :
495 6 : return;
496 : };
497 : /* ------------------------------------------------------------------------- */
498 : LOCAL void pl_case_started (unsigned moduleid,
499 : unsigned caseid,
500 : long testrunid)
501 27 : {
502 : internal_test_run_info *tri;
503 :
504 27 : if(tfwif_test_runs_==INITPTR){
505 25 : tfwif_test_runs_=dl_list_create();
506 : }
507 :
508 27 : tri = NEW (internal_test_run_info);
509 27 : tri->case_id_ = caseid;
510 27 : tri->test_run_id_ = testrunid;
511 27 : tri->module_id_ = moduleid;
512 27 : tri->status_ = TP_RUNNING;
513 27 : tri->group_id_=0;
514 :
515 27 : dl_list_add (tfwif_test_runs_, tri);
516 :
517 : return;
518 : };
519 : /* ------------------------------------------------------------------------- */
520 : LOCAL void pl_case_paused (long testrunid)
521 5 : {
522 5 : internal_test_run_info *tri = INITPTR;
523 5 : DLListIterator test_run_item = DLListNULLIterator;
524 :
525 :
526 5 : pthread_mutex_lock (&tfwif_mutex_);
527 5 : test_run_item = dl_list_find (dl_list_head (tfwif_test_runs_),
528 : dl_list_tail (tfwif_test_runs_),
529 : _find_testrun_by_id,
530 : (const void *)&testrunid);
531 5 : pthread_mutex_unlock (&tfwif_mutex_);
532 :
533 5 : tri = dl_list_data (test_run_item);
534 5 : if(tri->status_ == TP_RUNNING &&
535 : tri->test_run_id_ == testrunid){
536 5 : tri->status_ = TP_PAUSED;
537 : }
538 :
539 : return;
540 : };
541 : /* ------------------------------------------------------------------------- */
542 : LOCAL void pl_case_resumed (long testrunid)
543 1 : {
544 1 : internal_test_run_info *tri = INITPTR;
545 1 : DLListIterator test_run_item = DLListNULLIterator;
546 :
547 :
548 1 : pthread_mutex_lock (&tfwif_mutex_);
549 1 : test_run_item = dl_list_find (dl_list_head (tfwif_test_runs_),
550 : dl_list_tail (tfwif_test_runs_),
551 : _find_testrun_by_id,
552 : (const void *)&testrunid);
553 1 : pthread_mutex_unlock (&tfwif_mutex_);
554 :
555 1 : tri = dl_list_data (test_run_item);
556 1 : if(tri->status_==TP_PAUSED &&
557 : tri->test_run_id_ == testrunid){
558 1 : tri->status_ = TP_RUNNING;
559 : }
560 :
561 : return;
562 : };
563 : /* ------------------------------------------------------------------------- */
564 : LOCAL void pl_msg_print (long testrunid, char *message)
565 4 : {
566 :
567 4 : printf ("test module message: %s\n", message);
568 4 : tfwif_callbacks.print_callback_ (testrunid, message);
569 :
570 : return;
571 : };
572 : /* ------------------------------------------------------------------------- */
573 : LOCAL void pl_new_module (char *modulename, unsigned moduleid)
574 96 : {
575 : internal_module_info *mi;
576 :
577 96 : mi = NEW (internal_module_info);
578 96 : STRCPY(mi->module_name_, modulename, 128);
579 96 : mi->test_case_list_ = dl_list_create();
580 96 : mi->module_id_ = moduleid;
581 96 : mi->module_ready_ = 0;
582 :
583 96 : pthread_mutex_lock (&tfwif_mutex_);
584 96 : MIN_DEBUG ("adding module to %x", tfwif_modules_);
585 96 : dl_list_add (tfwif_modules_, mi);
586 96 : pthread_mutex_unlock (&tfwif_mutex_);
587 :
588 :
589 :
590 : return;
591 : };
592 : /* ------------------------------------------------------------------------- */
593 : LOCAL void pl_module_ready ( unsigned moduleid)
594 98 : {
595 : internal_module_info *mi;
596 : DLListIterator it;
597 :
598 98 : pthread_mutex_lock (&tfwif_mutex_);
599 :
600 98 : it = dl_list_find (dl_list_head (tfwif_modules_),
601 : dl_list_tail (tfwif_modules_),
602 : _find_mod_by_id,
603 : (const void *)&moduleid);
604 98 : pthread_mutex_unlock (&tfwif_mutex_);
605 98 : if (it == INITPTR)
606 0 : return;
607 :
608 98 : ready_module_count_ ++;
609 98 : mi = dl_list_data (it);
610 98 : mi->module_ready_ = 1;
611 :
612 98 : return;
613 : };
614 : /* ------------------------------------------------------------------------- */
615 : LOCAL void pl_no_module (char *modulename)
616 0 : {
617 : return;
618 : };
619 : /* ------------------------------------------------------------------------- */
620 : LOCAL void pl_new_case (unsigned moduleid, unsigned caseid, char *casetitle)
621 316 : {
622 : internal_module_info *mi;
623 : min_case *mc;
624 : DLListIterator it;
625 :
626 316 : pthread_mutex_lock (&tfwif_mutex_);
627 :
628 316 : it = dl_list_find (dl_list_head (tfwif_modules_),
629 : dl_list_tail (tfwif_modules_),
630 : _find_mod_by_id,
631 : (const void *)&moduleid);
632 :
633 316 : if (it == INITPTR) {
634 0 : pthread_mutex_unlock (&tfwif_mutex_);
635 0 : MIN_WARN ("NO MODULE FOUND WITH ID %s",moduleid);
636 0 : return;
637 : }
638 316 : mi = dl_list_data (it);
639 316 : mc = NEW(min_case);
640 316 : mc->case_id_ = caseid;
641 316 : STRCPY (mc->case_name_, casetitle, 256);
642 316 : dl_list_add (mi->test_case_list_, mc);
643 316 : pthread_mutex_unlock (&tfwif_mutex_);
644 :
645 316 : return;
646 : };
647 :
648 : /* ------------------------------------------------------------------------- */
649 : LOCAL void pl_error_report (char *error)
650 0 : {
651 0 : printf ("%s\n", error);
652 : return;
653 : };
654 :
655 : /* ------------------------------------------------------------------------- */
656 : LOCAL void pl_send_rcp (char *cmd, char *sender, char *rcvr, char* msg,
657 : int param)
658 6 : {
659 : Text *tx;
660 :
661 6 : tx = tx_create (cmd);
662 6 : tx_c_append (tx, " ");
663 6 : tx_c_append (tx, sender);
664 6 : tx_c_append (tx, " ");
665 6 : tx_c_append (tx, rcvr);
666 6 : tx_c_append (tx, " ");
667 6 : tx_c_append (tx, msg);
668 :
669 6 : MIN_DEBUG ("SENDING TO EXTIF :%s", tx_share_buf (tx));
670 :
671 6 : tfwif_callbacks.send_extif_msg_ (tx_share_buf (tx),
672 : strlen (tx_share_buf (tx)));
673 :
674 6 : tx_destroy (&tx);
675 :
676 : return;
677 : };
678 :
679 : /* ------------------------------------------------------------------------- */
680 : LOCAL int _find_mod_by_id (const void *a, const void *b)
681 792 : {
682 792 : internal_module_info *tmp1 = (internal_module_info*)a;
683 792 : unsigned *tmp2 = (unsigned*)b;
684 :
685 792 : if (tmp1->module_id_ ==(*tmp2)) return 0;
686 378 : else return -1;
687 : }
688 :
689 : /* ------------------------------------------------------------------------- */
690 : LOCAL int _find_mod_by_name (const void *a, const void *b)
691 163 : {
692 163 : internal_module_info *tmp1 = (internal_module_info*)a;
693 :
694 163 : return strncmp (tmp1->module_name_, (const char *)b, 128);
695 : }
696 :
697 : /*---------------------------------------------------------------------------*/
698 : LOCAL int _find_testrun_by_id (const void *a, const void *b)
699 25 : {
700 25 : internal_test_run_info *trp1 = (internal_test_run_info*)a;
701 25 : unsigned *tmp2 = (unsigned*)b;
702 :
703 25 : if (trp1->test_run_id_ ==(*tmp2)) return 0;
704 6 : else return -1;
705 : }
706 :
707 : /*---------------------------------------------------------------------------*/
708 : LOCAL void _del_internal_mod_info (void *data)
709 57 : {
710 57 : internal_module_info *mi = (internal_module_info*)data;
711 57 : dl_list_foreach (dl_list_head (mi->test_case_list_),
712 : dl_list_tail (mi->test_case_list_),
713 : free);
714 57 : dl_list_free (&mi->test_case_list_);
715 57 : DELETE (mi);
716 57 : }
717 :
718 : /* ================= OTHER EXPORTED FUNCTIONS ============================== */
719 : /* None */
720 :
721 :
722 : /* ================= TESTS FOR LOCAL FUNCTIONS ============================= */
723 : #ifdef MIN_UNIT_TEST
724 : #include "mintfwif.tests"
725 :
726 : #endif /* MIN_UNIT_TEST */
727 :
728 : /* End of file */
|
