1 : /*
2 : * This file is part of MIN Test Framework. Copyright © 2008 Nokia Corporation
3 : * and/or its subsidiary(-ies).
4 : * Contact: Sampo Saaristo
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 : #include "check.h"
21 :
22 : /**
23 : * @file tec_events.tests
24 : * @version 0.1
25 : * @brief This file contains tests for Event System in
26 : * MIN Test Engine Controller
27 : */
28 :
29 : minTestEventParam_t ind_param, sta_param;
30 :
31 : #define FILL_IND() do {\
32 : ind_param.event.event_name_ = (char *)malloc(strlen("test_indications") + 1);\
33 : strcpy (ind_param.event.event_name_, "test_indications"); \
34 : ind_param.event.event_type_ = EIndication;} while (0)
35 :
36 : #define FILL_STA() do {\
37 : sta_param.event.event_name_ = (char *) malloc (strlen ("test_states") + 1);\
38 : strcpy (sta_param.event.event_name_, "test_states");\
39 : sta_param.event.event_type_ = EState;} while(0)
40 :
41 :
42 : void setup (void)
43 12 : {
44 12 : FILL_IND();
45 12 : FILL_STA();
46 12 : event_system_init ();
47 :
48 12 : }
49 :
50 : void teardown (void)
51 12 : {
52 12 : event_system_cleanup();
53 12 : }
54 :
55 1 : START_TEST(test_add_ind_event)
56 : {
57 : min_event_t *e;
58 :
59 1 : e = add_ind_event (&ind_param);
60 1 : fail_if (e == INITPTR);
61 :
62 1 : e = add_ind_event (&sta_param);
63 1 : fail_unless (e == INITPTR);
64 : }
65 1 : END_TEST
66 :
67 1 : START_TEST(test_find_ind)
68 : {
69 : min_event_t *e, *ee;
70 1 : e = find_ind_event (&ind_param, NULL);
71 1 : fail_unless(e == INITPTR);
72 :
73 1 : e = add_ind_event (&ind_param);
74 1 : fail_if (e == INITPTR);
75 :
76 1 : FILL_IND();
77 :
78 1 : ee = find_ind_event (&ind_param, NULL);
79 :
80 1 : fail_unless (e == ee);
81 : }
82 1 : END_TEST
83 :
84 1 : START_TEST(test_registration)
85 : {
86 : int ret;
87 : min_event_t *e;
88 : minEventSrc_t esrc;
89 :
90 1 : esrc.remote = 0;
91 1 : esrc.pid = 2345;
92 :
93 1 : e = add_ind_event (&ind_param);
94 1 : fail_if (e == INITPTR);
95 :
96 1 : ret = event_is_registered (e, &esrc);
97 1 : fail_unless (ret == 0);
98 :
99 1 : event_add_registration (e, &esrc);
100 :
101 1 : ret = event_is_registered (e, &esrc);
102 1 : fail_unless (ret == 1);
103 :
104 1 : ret = event_del_registration (e, &esrc);
105 1 : fail_unless (ret == 0);
106 :
107 1 : ret = event_is_registered (e, &esrc);
108 1 : fail_unless (ret == 0);
109 : }
110 1 : END_TEST
111 :
112 1 : START_TEST(test_ind_request)
113 : {
114 : int ret;
115 : minEventSrc_t esrc;
116 :
117 1 : esrc.remote = 0;
118 1 : esrc.pid = 2211;
119 :
120 1 : ret = ind_event_handle_request (&ind_param, &esrc);
121 :
122 1 : fail_unless (ret == 0);
123 :
124 1 : ind_param.event.event_name_ = NEW2(char *,
125 : strlen("test_indications") + 1);
126 1 : STRCPY (ind_param.event.event_name_, "test_indications",
127 : MaxMinEventName);
128 :
129 :
130 1 : ret = ind_event_handle_request (&ind_param, &esrc);
131 :
132 1 : fail_unless (ret == 1);
133 :
134 : }
135 1 : END_TEST
136 :
137 1 : START_TEST(test_ind_waiting)
138 : {
139 : int ret;
140 : int stat;
141 :
142 : minEventSrc_t esrc;
143 :
144 1 : esrc.remote = 0;
145 1 : esrc.pid = 10;
146 :
147 1 : ret = ind_event_handle_request (&ind_param, &esrc);
148 1 : fail_unless (ret == 0);
149 :
150 1 : FILL_IND();
151 1 : ret = ind_event_handle_wait (&ind_param, &esrc, &stat);
152 1 : fail_unless (ret == 0);
153 :
154 1 : FILL_IND();
155 1 : ret = ind_event_handle_wait (&ind_param, &esrc, &stat);
156 1 : fail_unless (ret == 1);
157 :
158 : }
159 1 : END_TEST
160 :
161 1 : START_TEST(test_ind_release)
162 : {
163 : int ret;
164 : minEventSrc_t esrc;
165 :
166 1 : esrc.remote = 0;
167 1 : esrc.pid = 1000;
168 :
169 1 : ret = ind_event_handle_request (&ind_param, &esrc);
170 1 : fail_unless (ret == 0);
171 :
172 1 : FILL_IND();
173 :
174 1 : esrc.pid = 1001;
175 1 : ret = ind_event_handle_release (&ind_param, &esrc);
176 1 : fail_unless (ret == 1);
177 :
178 1 : FILL_IND();
179 :
180 1 : esrc.pid = 1000;
181 1 : ret = ind_event_handle_release (&ind_param, &esrc);
182 1 : fail_unless (ret == 0);
183 :
184 : }
185 1 : END_TEST
186 :
187 :
188 1 : START_TEST(test_add_state_event)
189 : {
190 : min_event_t *e;
191 :
192 1 : e = add_state_event (&sta_param);
193 1 : fail_if (e == INITPTR);
194 :
195 1 : FILL_STA();
196 :
197 1 : e = add_state_event (&ind_param);
198 1 : fail_unless (e == INITPTR);
199 : }
200 1 : END_TEST
201 :
202 1 : START_TEST (test_set_set_unset_unset)
203 : {
204 : int ret;
205 : minEventSrc_t esrc;
206 :
207 1 : esrc.remote = 0;
208 1 : esrc.pid = 8180;
209 :
210 1 : ret = state_event_handle_set (&sta_param, &esrc);
211 1 : fail_unless (ret == 0);
212 :
213 1 : FILL_STA();
214 1 : ret = state_event_handle_set (&sta_param, &esrc);
215 1 : fail_unless (ret == 1);
216 :
217 :
218 1 : FILL_STA();
219 1 : ret = state_event_handle_unset (&sta_param, &esrc);
220 1 : fail_unless (ret == 0);
221 :
222 1 : FILL_STA();
223 :
224 1 : ret = state_event_handle_unset (&sta_param, &esrc);
225 1 : fail_unless (ret == 1);
226 : }
227 1 : END_TEST
228 :
229 1 : START_TEST (test_set_unset_set_unset)
230 : {
231 : int ret;
232 : minEventSrc_t esrc;
233 :
234 1 : esrc.remote = 0;
235 1 : esrc.pid = 8180;
236 :
237 1 : ret = state_event_handle_set (&sta_param, &esrc);
238 1 : fail_unless (ret == 0);
239 :
240 1 : FILL_STA();
241 1 : ret = state_event_handle_unset (&sta_param, &esrc);
242 :
243 1 : FILL_STA();
244 1 : sta_param.event.event_type_ = EState;
245 :
246 :
247 1 : FILL_STA();
248 1 : ret = state_event_handle_set (&sta_param, &esrc);
249 1 : fail_unless (ret == 0);
250 :
251 1 : FILL_STA();
252 1 : ret = state_event_handle_unset (&sta_param, &esrc);
253 1 : fail_unless (ret == 0);
254 :
255 : }
256 1 : END_TEST
257 :
258 1 : START_TEST (test_req_req_rel_rel)
259 : {
260 : int ret;
261 : minEventSrc_t esrc;
262 :
263 1 : esrc.remote = 0;
264 1 : esrc.pid = 1081;
265 :
266 1 : ret = state_event_handle_request (&sta_param, &esrc);
267 1 : fail_unless (ret == 0);
268 :
269 1 : FILL_STA();
270 1 : ret = state_event_handle_request (&sta_param, &esrc);
271 1 : fail_unless (ret == 1);
272 :
273 1 : FILL_STA();
274 1 : ret = state_event_handle_release (&sta_param, &esrc);
275 1 : fail_unless (ret == 0);
276 :
277 1 : FILL_STA();
278 1 : ret = state_event_handle_release (&sta_param, &esrc);
279 1 : fail_unless (ret == 1);
280 : }
281 1 : END_TEST
282 :
283 :
284 1 : START_TEST (test_set_req_wait_rel_unset)
285 : {
286 : int ret, stat;
287 : minEventSrc_t client, server;
288 :
289 1 : client.remote = 0;
290 1 : client.pid = 1010;
291 1 : server.remote = 0;
292 1 : server.pid = 2020;
293 :
294 1 : ret = state_event_handle_set (&sta_param, &server);
295 1 : fail_unless (ret == 0);
296 :
297 1 : FILL_STA();
298 1 : ret = state_event_handle_request (&sta_param, &client);
299 1 : fail_unless (ret == 0);
300 :
301 1 : FILL_STA();
302 1 : ret = state_event_handle_wait (&sta_param, &client, &stat);
303 1 : fail_unless (ret == 0);
304 :
305 1 : FILL_STA();
306 1 : ret = state_event_handle_release (&sta_param, &client);
307 1 : fail_unless (ret == 0);
308 :
309 1 : FILL_STA();
310 1 : ret = state_event_handle_unset (&sta_param, &server);
311 1 : fail_unless (ret == 0);
312 :
313 : }
314 1 : END_TEST
315 :
316 1 : START_TEST (test_req_wait_wait_set)
317 : {
318 : int ret, stat;
319 : minEventSrc_t client, server;
320 :
321 1 : client.remote = 0;
322 1 : client.pid = 100;
323 1 : server.remote = 0;
324 1 : server.pid = 200;
325 :
326 :
327 1 : ret = state_event_handle_request (&sta_param, &client);
328 1 : fail_unless (ret == 0);
329 :
330 1 : FILL_STA();
331 1 : ret = state_event_handle_wait (&sta_param, &client, &stat);
332 1 : fail_unless (ret == 0);
333 :
334 1 : FILL_STA();
335 1 : ret = state_event_handle_wait (&sta_param, &client, &stat);
336 1 : fail_unless (ret == 1);
337 :
338 1 : FILL_STA();
339 1 : ret = state_event_handle_set (&sta_param, &server);
340 1 : fail_unless (ret == 0);
341 :
342 : }
343 1 : END_TEST
344 :
345 : Suite* tec_events_suite()
346 1 : {
347 1 : Suite * s = suite_create ("tec_events");
348 1 : TCase* core = tcase_create("core");
349 :
350 1 : tcase_add_checked_fixture (core, setup, teardown);
351 :
352 1 : tcase_add_test (core, test_add_ind_event);
353 1 : tcase_add_test (core, test_find_ind);
354 1 : tcase_add_test (core, test_registration);
355 1 : tcase_add_test (core, test_ind_request);
356 1 : tcase_add_test (core, test_ind_waiting);
357 1 : tcase_add_test (core, test_ind_release);
358 :
359 1 : tcase_add_test (core, test_add_state_event);
360 1 : tcase_add_test (core, test_set_set_unset_unset);
361 1 : tcase_add_test (core, test_set_unset_set_unset);
362 1 : tcase_add_test (core, test_req_req_rel_rel);
363 1 : tcase_add_test (core, test_req_wait_wait_set);
364 1 : tcase_add_test (core, test_set_req_wait_rel_unset);
365 :
366 1 : suite_add_tcase (s, core);
367 1 : return s;
368 : }
369 :
370 : int tec_events_tests()
371 1 : {
372 : int number_failed;
373 : Suite * s;
374 : SRunner * sr;
375 :
376 1 : number_failed = 0;
377 1 : s = tec_events_suite ();
378 1 : sr = srunner_create (s);
379 1 : srunner_set_fork_status (sr, CK_NOFORK);
380 1 : srunner_run_all(sr, CK_NORMAL);
381 1 : number_failed = srunner_ntests_failed(sr);
382 1 : srunner_free(sr);
383 :
384 1 : return number_failed;
385 : }
386 :
|
