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 : #include "equal.h"
19 :
20 : /**
21 : * GLOBAL VARIABLES SECTION
22 : */
23 : #ifdef TEST_VAR_DECLARATIONS
24 : /**
25 : * Example of variable common for some test cases
26 : */
27 : int a, b, i, k, new;
28 : int retval;
29 : int aaa[3];
30 : int *pom, *value;
31 : DLListIterator it;
32 : DLList *l;
33 : #endif /* TEST_VAR_DECLARATIONS */
34 : /**
35 : * END OF GLOBAL VARIABLES SECTION
36 : */
37 :
38 :
39 : /**
40 : * TEST CASES SECTION
41 : */
42 : #ifdef TEST_CASES
43 : /**
44 : * MIN_SETUP defines activities needed before every test case.
45 : */
46 81 : MIN_SETUP {
47 20 : l = dl_list_create ();
48 20 : it = DLListNULLIterator;
49 20 : retval = -1;
50 20 : new = 55;
51 20 : k = 0;
52 20 : pom = INITPTR;
53 20 : aaa[0] = 5;
54 20 : aaa[1] = 7;
55 20 : aaa[2] = 98;
56 :
57 : }
58 :
59 : /**
60 : * MIN_TEARDOWN defines activities needed after every test case
61 : */
62 81 : MIN_TEARDOWN {
63 20 : if (l != INITPTR)
64 10 : dl_list_free (&l);
65 : }
66 :
67 : /**
68 : * MIN_TESTDEFINE defines a test case
69 : *
70 : */
71 :
72 : /* ------------------------------------------------------------------------- */
73 81 : MIN_TESTDEFINE (test_dllist_create)
74 : {
75 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
76 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 0);
77 : }
78 :
79 : /* ------------------------------------------------------------------------- */
80 81 : MIN_TESTDEFINE (test_dllist_free)
81 : {
82 1 : dl_list_free (&l);
83 1 : MIN_ASSERT_EQUALS (l, INITPTR);
84 : }
85 :
86 : /* ------------------------------------------------------------------------- */
87 81 : MIN_TESTDEFINE (test_dllist_add_item)
88 : {
89 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
90 1 : a = 5;
91 1 : retval = dl_list_add (l, &a);
92 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
93 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 1);
94 1 : dl_list_free (&l);
95 1 : retval = dl_list_add (INITPTR, &a);
96 1 : MIN_ASSERT_EQUALS (retval, -1);
97 : }
98 :
99 : /* ------------------------------------------------------------------------- */
100 81 : MIN_TESTDEFINE (test_dllist_add_item_at_1)
101 : {
102 1 : a = 1;
103 1 : dl_list_free (&l);
104 1 : retval = dl_list_add_at (INITPTR, &a, 0);
105 1 : MIN_ASSERT_EQUALS (retval, -1);
106 1 : retval = dl_list_add_at (INITPTR, &a, 99);
107 1 : MIN_ASSERT_EQUALS (retval, -1);
108 : }
109 :
110 : /* ------------------------------------------------------------------------- */
111 81 : MIN_TESTDEFINE (test_dllist_add_item_at_2)
112 : {
113 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
114 :
115 1 : retval = dl_list_add_at (l, &aaa[0], 0);
116 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
117 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 1);
118 :
119 1 : retval = dl_list_add_at (l, &aaa[1], 1);
120 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
121 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 2);
122 :
123 1 : retval = dl_list_add_at (l, &aaa[2], 2);
124 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
125 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 3);
126 :
127 4 : for (k = 0; k < dl_list_size (l); k++) {
128 3 : pom = (int *)dl_list_data (dl_list_at (l, k));
129 3 : MIN_ASSERT_NOT_EQUALS (pom, INITPTR);
130 3 : MIN_ASSERT_EQUALS (*pom, aaa[k]);
131 : }
132 : }
133 :
134 : /* ------------------------------------------------------------------------- */
135 81 : MIN_TESTDEFINE (test_dllist_add_item_at_3)
136 : {
137 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
138 :
139 1 : retval = dl_list_add_at (l, &aaa[0], 0);
140 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
141 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 1);
142 :
143 1 : retval = dl_list_add_at (l, &aaa[1], 0);
144 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
145 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 2);
146 :
147 1 : retval = dl_list_add_at (l, &aaa[2], 0);
148 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
149 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 3);
150 :
151 4 : for (k = 0; k < dl_list_size (l); k++) {
152 3 : pom = (int *)dl_list_data (dl_list_at (l, k));
153 3 : MIN_ASSERT_NOT_EQUALS (pom, INITPTR);
154 3 : MIN_ASSERT_EQUALS (*pom, aaa[2 - k]);
155 : }
156 : }
157 :
158 : /* ------------------------------------------------------------------------- */
159 81 : MIN_TESTDEFINE (test_dllist_add_item_at_4)
160 : {
161 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
162 :
163 1 : retval = dl_list_add_at (l, &aaa[0], 1);
164 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
165 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 1);
166 :
167 1 : retval = dl_list_add_at (l, &aaa[1], 1);
168 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
169 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 2);
170 :
171 1 : retval = dl_list_add_at (l, &aaa[2], 1);
172 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
173 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 3);
174 :
175 1 : pom = (int *)dl_list_data (dl_list_at (l, 0));
176 1 : MIN_ASSERT_NOT_EQUALS (pom, INITPTR);
177 1 : MIN_ASSERT_EQUALS (*pom, aaa[0]);
178 :
179 1 : pom = (int *)dl_list_data (dl_list_at (l, 1));
180 1 : MIN_ASSERT_NOT_EQUALS (pom, INITPTR);
181 1 : MIN_ASSERT_EQUALS (*pom, aaa[2]);
182 :
183 1 : pom = (int *)dl_list_data (dl_list_at (l, 2));
184 1 : MIN_ASSERT_NOT_EQUALS (pom, INITPTR);
185 1 : MIN_ASSERT_EQUALS (*pom, aaa[1]);
186 :
187 : }
188 :
189 : /* ------------------------------------------------------------------------- */
190 81 : MIN_TESTDEFINE (test_dllist_remove_item)
191 : {
192 1 : a = 8;
193 1 : b = 9;
194 1 : retval = -1;
195 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
196 1 : dl_list_add (l, &a);
197 1 : dl_list_add (l, &b);
198 1 : retval = dl_list_remove_it (dl_list_find (dl_list_head (l)
199 : , dl_list_tail (l)
200 : , equal, &a));
201 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
202 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 1);
203 : }
204 :
205 : /* ------------------------------------------------------------------------- */
206 81 : MIN_TESTDEFINE (test_dllist_add_multiple_item)
207 : {
208 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
209 4 : for (i = 0; i < 3; i++) {
210 3 : retval = dl_list_add (l, &aaa[i]);
211 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
212 : }
213 4 : for (k = 0; k < dl_list_size (l); k++) {
214 3 : pom = (int *)dl_list_data (dl_list_at (l, k));
215 3 : MIN_ASSERT_NOT_EQUALS (pom, INITPTR);
216 3 : MIN_ASSERT_EQUALS (*pom, aaa[k]);
217 : }
218 : }
219 :
220 : /* ------------------------------------------------------------------------- */
221 81 : MIN_TESTDEFINE (test_dllist_two_lists)
222 : {
223 1 : DLList *ll = dl_list_create ();
224 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
225 1 : MIN_ASSERT_NOT_EQUALS (ll, INITPTR);
226 1 : retval = dl_list_add (l, &a);
227 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
228 1 : MIN_ASSERT_NOT_EQUALS (dl_list_size (l), dl_list_size (ll));
229 1 : dl_list_free (&ll);
230 : }
231 :
232 : /* ------------------------------------------------------------------------- */
233 81 : MIN_TESTDEFINE (test_dllist_alter_item_by_iterator)
234 : {
235 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
236 4 : for (i = 0; i < 3; i++) {
237 3 : retval = dl_list_add (l, &aaa[i]);
238 3 : MIN_ASSERT_NOT_EQUALS_DESC (retval, -1, "Adding failed.");
239 : }
240 1 : retval = dl_list_alter_it (dl_list_head (l), &aaa[2]);
241 1 : MIN_ASSERT_NOT_EQUALS_DESC (retval, -1, "dl_list_alter_it failed");
242 1 : value = (int *)dl_list_data (dl_list_head (l));
243 1 : MIN_ASSERT_EQUALS_DESC (*value, aaa[2], "Alter error");
244 1 : dl_list_alter_it (dl_list_head (l), INITPTR);
245 1 : MIN_ASSERT_NOT_EQUALS_DESC (retval, -1, "dl_list_alter_it failed when value NULL.");
246 1 : dl_list_free (&l);
247 1 : retval = dl_list_alter_it (INITPTR, &aaa[2]);
248 1 : MIN_ASSERT_EQUALS_DESC (retval, -1, "dl_list_alter_it executed when list is NULL.");
249 : }
250 :
251 : /* ------------------------------------------------------------------------- */
252 81 : MIN_TESTDEFINE (test_dllist_alter_item_by_data)
253 : {
254 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
255 4 : for (i = 0; i < 3; i++) {
256 3 : retval = dl_list_add (l, &aaa[i]);
257 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
258 : }
259 1 : pom = dl_list_data (dl_list_head (l));
260 1 : *(int *)pom = aaa[2];
261 1 : value = (int *)dl_list_data (dl_list_head (l));
262 1 : MIN_ASSERT_EQUALS (*value, aaa[2]);
263 : }
264 :
265 : /* ------------------------------------------------------------------------- */
266 81 : MIN_TESTDEFINE (test_dllist_next_functionality)
267 : {
268 1 : it = DLListNULLIterator;
269 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
270 4 : for (i = 0; i < 3; i++) {
271 3 : retval = dl_list_add (l, &aaa[i]);
272 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
273 : }
274 1 : it = dl_list_next (dl_list_head (l));
275 1 : value = (int *)dl_list_data (it);
276 1 : MIN_ASSERT_EQUALS (*value, aaa[1]);
277 1 : dl_list_free (&l);
278 1 : it = dl_list_next (INITPTR);
279 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
280 : }
281 :
282 : /* ------------------------------------------------------------------------- */
283 81 : MIN_TESTDEFINE (test_dllist_prev_functionality)
284 : {
285 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
286 4 : for (i = 0; i < 3; i++) {
287 3 : retval = dl_list_add (l, &aaa[i]);
288 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
289 : }
290 1 : it = dl_list_prev (dl_list_tail (l));
291 1 : value = (int *)dl_list_data (it);
292 1 : MIN_ASSERT_EQUALS (*value, aaa[1]);
293 1 : dl_list_free (&l);
294 1 : it = dl_list_prev (INITPTR);
295 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
296 : }
297 :
298 : /* ------------------------------------------------------------------------- */
299 81 : MIN_TESTDEFINE (test_dllist_head)
300 : {
301 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
302 4 : for (i = 0; i < 3; i++) {
303 3 : retval = dl_list_add (l, &aaa[i]);
304 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
305 : }
306 1 : it = dl_list_head (l);
307 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
308 1 : value = (int *)dl_list_data (it);
309 1 : MIN_ASSERT_EQUALS (*value, aaa[0]);
310 1 : dl_list_free (&l);
311 1 : it = dl_list_head (INITPTR);
312 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
313 : }
314 :
315 : /* ------------------------------------------------------------------------- */
316 81 : MIN_TESTDEFINE (test_dllist_tail)
317 : {
318 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
319 4 : for (i = 0; i < 3; i++) {
320 3 : retval = dl_list_add (l, &aaa[i]);
321 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
322 : }
323 1 : it = dl_list_tail (l);
324 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
325 1 : value = (int *)dl_list_data (it);
326 1 : MIN_ASSERT_EQUALS (*value, aaa[2]);
327 1 : dl_list_free (&l);
328 1 : it = dl_list_tail (INITPTR);
329 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
330 : }
331 :
332 : /* ------------------------------------------------------------------------- */
333 81 : MIN_TESTDEFINE (test_dllist_size)
334 : {
335 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
336 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 0);
337 1 : retval = dl_list_add (l, &aaa[0]);
338 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
339 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 1);
340 1 : retval = dl_list_add (l, &aaa[1]);
341 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
342 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 2);
343 1 : retval = dl_list_add (l, &aaa[2]);
344 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
345 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 3);
346 1 : it = dl_list_tail (l);
347 1 : retval = dl_list_remove_it (it);
348 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
349 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 2);
350 1 : dl_list_free (&l);
351 1 : retval = dl_list_size (INITPTR);
352 1 : MIN_ASSERT_EQUALS (retval, -1);
353 : }
354 :
355 : /* ------------------------------------------------------------------------- */
356 81 : MIN_TESTDEFINE (test_dllist_remove)
357 : {
358 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
359 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 0);
360 4 : for (i = 0; i < 3; i++) {
361 3 : retval = dl_list_add (l, &aaa[i]);
362 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
363 : }
364 1 : it = dl_list_tail (l);
365 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
366 1 : retval = dl_list_remove_it (it);
367 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
368 1 : it = dl_list_head (l);
369 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
370 1 : retval = dl_list_remove_it (it);
371 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
372 1 : retval = dl_list_add (l, &aaa[0]);
373 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
374 1 : it = dl_list_head (l);
375 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
376 1 : retval = dl_list_remove_it (it);
377 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
378 1 : it = dl_list_head (l);
379 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
380 1 : retval = dl_list_remove_it (it);
381 1 : MIN_ASSERT_NOT_EQUALS (retval, -1);
382 1 : it = dl_list_head (l);
383 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
384 1 : retval = dl_list_remove_it (it);
385 1 : MIN_ASSERT_EQUALS (retval, -1);
386 : }
387 :
388 : /* ------------------------------------------------------------------------- */
389 81 : MIN_TESTDEFINE (test_dllist_data_at)
390 : {
391 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
392 1 : MIN_ASSERT_EQUALS (dl_list_size (l), 0);
393 4 : for (i = 0; i < 3; i++) {
394 3 : retval = dl_list_add (l, &aaa[i]);
395 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
396 : }
397 1 : it = dl_list_at (l, 0);
398 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
399 1 : value = (int *)dl_list_data (it);
400 1 : MIN_ASSERT_EQUALS (*value, aaa[0]);
401 1 : it = dl_list_at (l, 1);
402 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
403 1 : value = (int *)dl_list_data (it);
404 1 : MIN_ASSERT_EQUALS (*value, aaa[1]);
405 1 : it = dl_list_at (l, 2);
406 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
407 1 : value = (int *)dl_list_data (it);
408 1 : MIN_ASSERT_EQUALS (*value, aaa[2]);
409 1 : it = dl_list_at (l, 3);
410 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
411 1 : dl_list_free (&l);
412 1 : value = (int *)dl_list_data (INITPTR);
413 1 : MIN_ASSERT_EQUALS (value, DLListNULLIterator);
414 : }
415 :
416 : /* ------------------------------------------------------------------------- */
417 81 : MIN_TESTDEFINE (test_dllist_find)
418 : {
419 1 : MIN_ASSERT_NOT_EQUALS (l, INITPTR);
420 4 : for (i = 0; i < 3; i++) {
421 3 : retval = dl_list_add (l, &aaa[i]);
422 3 : MIN_ASSERT_NOT_EQUALS (retval, -1);
423 : }
424 1 : it = dl_list_find (dl_list_head (l)
425 : , dl_list_tail (l)
426 : , equal, &aaa[2]);
427 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
428 1 : value = (int *)dl_list_data (it);
429 1 : MIN_ASSERT_EQUALS (*value, aaa[2]);
430 :
431 1 : it = dl_list_find (dl_list_head (l)
432 : , dl_list_tail (l)
433 : , equal, &aaa[1]);
434 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
435 1 : value = (int *)dl_list_data (it);
436 1 : MIN_ASSERT_EQUALS (*value, aaa[1]);
437 :
438 1 : it = dl_list_find (dl_list_head (l)
439 : , dl_list_tail (l)
440 : , equal, &aaa[0]);
441 1 : MIN_ASSERT_NOT_EQUALS (it, DLListNULLIterator);
442 1 : value = (int *)dl_list_data (it);
443 1 : MIN_ASSERT_EQUALS (*value, aaa[0]);
444 :
445 1 : i = 17;
446 1 : it = dl_list_find (dl_list_head (l)
447 : , dl_list_tail (l)
448 : , equal, &i);
449 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
450 :
451 1 : it = dl_list_find (DLListNULLIterator, dl_list_tail (l)
452 : , equal, &aaa[2]);
453 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
454 :
455 1 : it = dl_list_find (dl_list_head (l)
456 : , DLListNULLIterator, equal, &aaa[2]);
457 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
458 :
459 1 : it = dl_list_find (DLListNULLIterator, DLListNULLIterator, equal,
460 : &aaa[2]);
461 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
462 :
463 1 : it = dl_list_find (dl_list_head (l)
464 : , dl_list_tail (l)
465 : , (ptr2compare) INITPTR, &aaa[2]);
466 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
467 :
468 1 : it = dl_list_find (dl_list_tail (l)
469 : , dl_list_head (l)
470 : , (ptr2compare) INITPTR, &aaa[2]);
471 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
472 :
473 1 : it = dl_list_find (dl_list_head (l)
474 : , dl_list_head (l)
475 : , (ptr2compare) INITPTR, &aaa[2]);
476 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
477 :
478 1 : it = dl_list_find (dl_list_tail (l)
479 : , dl_list_tail (l)
480 : , (ptr2compare) INITPTR, &aaa[2]);
481 1 : MIN_ASSERT_EQUALS (it, DLListNULLIterator);
482 : }
483 : /* ------------------------------------------------------------------------- */
484 :
485 : #endif
486 : /**
487 : * END OF TEST CASES SECTION
488 : */
|