LTP GCOV extension - code coverage report
Current view: directory - mintests - dllist_cases.c
Test: min.info
Date: 2009-06-18 Instrumented lines: 286
Code covered: 100.0 % Executed lines: 286

       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                 :  */

Generated by: LTP GCOV extension version 1.6