IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9143


Ignore:
Timestamp:
Oct 2, 2006, 8:51:47 PM (20 years ago)
Author:
drobbin
Message:

Made several changes. Finished bitSet testing, list testing. Minor changes to psList.c. Added lookupTable test to Makefile. minor changes to LookupTable.c

Location:
trunk/psLib
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/types/psList.c

    r9086 r9143  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.53 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-02 06:05:53 $
     8 *  @version $Revision: 1.54 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-03 06:51:47 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    574574    }
    575575
    576     if (list->n > 0) {
    577         arr = psArrayAlloc(list->n);
    578     } else {
    579         arr = psArrayAlloc(1);
    580     }
    581 
     576    //XXX: Following is unnecessary as a list->n = 0 should do ArrayAlloc(0) I believe.
     577    /*    if (list->n > 0) {
     578            arr = psArrayAlloc(list->n);
     579        } else {
     580            arr = psArrayAlloc(1);
     581        }
     582    */
     583    arr = psArrayAlloc(list->n);
    582584    arr->n = list->n;
    583585
    … …  
    618620        return NULL;
    619621    }
     622    if (func == NULL) {
     623        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     624                _("Specified psComparePtrFunc is NULL."));
     625        return list;
     626    }
    620627    // convert to indexable vector for use by qsort.
    621628    arr = psListToArray(list);

  • trunk/psLib/src/types/psLookupTable.c

    r8627 r9143  
    77*  @author Ross Harman, MHPCC
    88*
    9 *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-08-26 04:34:28 $
     9*  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-10-03 06:51:47 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    253253static void lookupTableFree(psLookupTable* table)
    254254{
    255     if (table == NULL) {
    256         return;
    257     }
    258 
    259255    psFree(table->values);
    260256    psFree(table->filename);
    … …  
    279275                                  long indexCol)
    280276{
    281     psLookupTable *outTable = NULL;
    282 
    283277    // Can't read table if you don't know its name
    284278    PS_ASSERT_PTR_NON_NULL(filename,NULL);
    … …  
    286280    // Can't read table if you don't know its format
    287281    PS_ASSERT_PTR_NON_NULL(format,NULL);
     282
     283    psLookupTable *outTable = NULL;
    288284
    289285    // Allocate lookup table

  • trunk/psLib/test/types/Makefile.am

    r9082 r9143  
    2828        tap_psHash_all \
    2929        tap_psBitSet_all \
    30         tap_psList_all
     30        tap_psList_all \
     31        tap_psLookupTable_all
    3132
    3233if BUILD_TESTS

  • trunk/psLib/test/types/execute_tap

    r9082 r9143  
    1717./tap_psBitSet_all
    1818./tap_psList_all
     19./tap_psLookupTable_all

  • trunk/psLib/test/types/tap_psArray_all.c

    r8731 r9143  
    2424int main(void)
    2525{
    26     plan_tests(25);
     26    plan_tests(28);
    2727
    2828    diag("Tests for psArray Functions");
    … …  
    4141    psArray *a = NULL;
    4242
     43    //Tests for psArrayAlloc
    4344    //Return NULL on attempting to allocate a negative size array
    4445    {
    4546        a = psArrayAlloc(-2);
    4647        ok( a == NULL,
    47             "psArrayAlloc:     return NULL for negative array-size input.");
     48            "psArrayAlloc:           return NULL for negative array-size input.");
    4849    }
    4950    //Return properly allocated psArray
    … …  
    5152        a = psArrayAlloc(0);
    5253        ok( a != NULL && psMemCheckArray(a),
    53             "psArrayAlloc:     return properly allocated psArray.");
    54     }
     54            "psArrayAlloc:           return properly allocated psArray.");
     55    }
     56    //Tests for psMemCheckArray
    5557    //Make sure psMemCheckArray works correctly - return false
    5658    {
    5759        int j = 2;
    5860        ok( !psMemCheckArray(&j),
    59             "psMemCheckArray:  return false for non-Array input.");
    60     }
     61            "psMemCheckArray:        return false for non-Array input.");
     62    }
     63    //Tests for psArrayRealloc
    6164    //Now try to reallocate the psArray - bigger
    6265    {
    6366        a = psArrayRealloc(a, 2);
    6467        ok ( psArrayLength(a) == 0 && a->nalloc == 2,
    65              "psArrayRealloc:   return properly reallocated psArray.");
     68             "psArrayRealloc:         return properly reallocated psArray.");
    6669    }
    6770    //Return NULL when trying to reallocate a NULL psArray
    … …  
    7073        temp = psArrayRealloc(temp, 1);
    7174        ok( temp == NULL,
    72             "psArrayRealloc:   return NULL for NULL input psArray.");
     75            "psArrayRealloc:         return NULL for NULL input psArray.");
    7376    }
    7477    //Attempt to reallocate the psArray - smaller
    … …  
    8386        *s32_2 = *((psS32*)(a->data[0]));
    8487        ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1,
    85             "psArrayRealloc:   return properly reallocated psArray.");
     88            "psArrayRealloc:         return properly reallocated psArray.");
    8689        skip_end();
    8790        psFree(s32);
    … …  
    9598        *s32 = *((psS32*)(a->data[0]));
    9699        ok( a->n == 1 && a->nalloc == 1 && *s32 == 1,
    97             "psArrayRealloc:   return same psArray for negative-size input.");
     100            "psArrayRealloc:         return same psArray for negative-size input.");
    98101        psFree(s32);
    99102    }
     103
    100104    //Attempt to free a NULL psArray
    101105    psArrayElementsFree(NULL);
    … …  
    104108        psArray *emptyArray = NULL;
    105109        ok( psArrayLength(emptyArray) == -1,
    106             "psArrayLength:    return -1 for NULL input psArray.");
     110            "psArrayLength:          return -1 for NULL input psArray.");
    107111    }
    108112
    … …  
    123127    psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
    124128
     129    //Tests for psArrayAdd
    125130    //Attempt to add element to NULL psArray.
    126131    {
    … …  
    129134        *s3 = *((psS32*)(temp->data[0]));
    130135        ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2,
    131             "psArrayAdd:       return array with newly added data.");
     136            "psArrayAdd:             return array with newly added data.");
    132137        psFree(temp);
    133138    }
    … …  
    141146        *s2 = *((psS32*)(a->data[0]));
    142147        ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2,
    143              "psArrayAdd:      return array with newly added data.");
    144     }
     148             "psArrayAdd:            return array with newly added data.");
     149    }
     150
     151    //Tests for psArrayRemove
    145152    //Setup array with 3 elements to test remove function
    146153    //Return false for attempting to remove from a NULL array
    … …  
    148155        psArray *temp = NULL;
    149156        ok( !psArrayRemove(temp, s2),
    150             "psArrayRemove:   return false for NULL input psArray.");
     157            "psArrayRemove:         return false for NULL input psArray.");
    151158    }
    152159    //Return true for successful removal
    153160    {
    154161        ok( psArrayRemove(a, s2) && a->n == 2,
    155             "psArrayRemove:   return true for successful removal.");
     162            "psArrayRemove:         return true for successful removal.");
     163    }
     164
     165    //Tests for psArrayRemoveByPos
     166    //Return false for NULL array input
     167    {
     168        ok( !psArrayRemoveByPos(NULL, 0),
     169            "psArrayRemoveByPos:    return false for NULL input psArray.");
     170    }
     171    //Return false for out-of-range index
     172    {
     173        ok( !psArrayRemoveByPos(a, 5),
     174            "psArrayRemoveByPos:    return false for out-of-range location.");
     175    }
     176    //Return true for successful removal
     177    {
     178        ok( psArrayRemoveByPos(a, 1) && a->n == 1,
     179            "psArrayRemoveByPos:    return true for successful removal.");
    156180    }
    157181
    … …  
    179203    *s3 = 3;
    180204
     205    //Tests for psArraySet
    181206    //Return false for trying to set a NULL psArray
    182207    {
    183208        ok( !psArraySet(a, 0, (psPtr)s1),
    184             "psArraySet:      return false for NULL input psArray.");
     209            "psArraySet:            return false for NULL input psArray.");
    185210    }
    186211    //Return false for trying to set an invalid position
    … …  
    188213    {
    189214        ok( !psArraySet(a, 2, (psPtr)s1),
    190             "psArraySet:      return false for invalid input position.");
     215            "psArraySet:            return false for invalid input position.");
    191216    }
    192217    //Return false for trying to set nalloc position
    … …  
    194219    {
    195220        ok( !psArraySet(a, a->nalloc, (psPtr)s2),
    196             "psArraySet:      return false for out-of-range position.");
     221            "psArraySet:            return false for out-of-range position.");
    197222    }
    198223    //Return false for an invalid position (-2 = out-of-range neg. index)
    199224    {
    200225        ok( !psArraySet(a, -2, (psPtr)s2),
    201             "psArraySet:      return false for out-of-range negative position.");
     226            "psArraySet:            return false for out-of-range negative position.");
    202227    }
    203228    //Return true for set to a->n position (< nalloc)
    … …  
    205230    {
    206231        ok( psArraySet(a, a->n, (psPtr)s2)  && a->n == 2,
    207             "psArraySet:      return true for valid input position.");
     232            "psArraySet:            return true for valid input position.");
    208233    }
    209234    //Return true for a negative index input
    … …  
    211236        ok( psArraySet(a, -2, (psPtr)s3) && a->n == 2 &&
    212237            *((psS32*)(a->data[0])) == 3,
    213             "psArraySet:      return true for valid negative input position.");
    214     }
    215 
     238            "psArraySet:            return true for valid negative input position.");
     239    }
     240
     241    //Tests for psArrayGet
    216242    //Return NULL for NULL array input
    217243    psS32 *s4 = NULL;
    … …  
    219245        s4 = (psS32*)psArrayGet(b, 0);
    220246        ok( s4 == NULL,
    221             "psArrayGet:      return NULL for NULL input psArray.");
     247            "psArrayGet:            return NULL for NULL input psArray.");
    222248    }
    223249    //Return NULL for an out-of-range index
    … …  
    225251        s4 = (psS32*)psArrayGet(a, a->n);
    226252        ok( s4 == NULL,
    227             "psArrayGet:      return NULL for out-of-range position.");
     253            "psArrayGet:            return NULL for out-of-range position.");
    228254    }
    229255    //Return NULL for an out-of-range negative index
    … …  
    231257        s4 = (psS32*)psArrayGet(a, -1-a->n);
    232258        ok( s4 == NULL,
    233             "psArrayGet:      return NULL for out-of-range negative position.");
     259            "psArrayGet:            return NULL for out-of-range negative position.");
    234260    }
    235261    //Return valid case
    … …  
    237263        s4 = (psS32*)psArrayGet(a, 1);
    238264        ok( *s4 == 1,
    239             "psArrayGet:      return correct value for valid position.");
     265            "psArrayGet:            return correct value for valid position.");
    240266    }
    241267
    … …  
    268294    psS32 *s6 = (psS32*)psAlloc(sizeof(psS32));
    269295
     296    //Tests for psArraySort
    270297    //Return NULL for attempt to sort NULL psArray input.
    271298    {
    … …  
    273300        temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr);
    274301        ok( temp == NULL,
    275             "psArraySort:     return NULL for NULL input psArray.");
     302            "psArraySort:           return NULL for NULL input psArray.");
    276303    }
    277304    //Return properly sorted psArray with descending psS32 elements - 3,2,1
    … …  
    282309        *s6 = *((psS32*)(a->data[2]));
    283310        ok( *s4 == 3 && *s5 == 2 && *s6 == 1,
    284             "psArraySort:     return properly sorted psArray.");
     311            "psArraySort:           return properly sorted psArray.");
    285312    }
    286313

  • trunk/psLib/test/types/tap_psBitSet_all.c

    r9082 r9143  
    3939    psBitSet *bs = NULL;
    4040
    41     //Return NULL for attempt to sort NULL psArray input.
     41    //Return NULL for attempt to Allocate BitSet of negative size.
    4242    {
    4343        noBits = psBitSetAlloc(-1);

  • trunk/psLib/test/types/tap_psList_all.c

    r9082 r9143  
    11/**
    2  *  C Implementation: tap_psHash_all
     2 *  C Implementation: tap_psList_all
    33 *
    4  * Description:  Tests for psHashAlloc, psHashAdd, psMemCheckHash, psHashLookup,
    5  *               psHashRemove, psHashKeyList, psHashToArray
     4 * Description:  Tests for psListAlloc, psListAdd, psMemCheckList, psListAddAfter,
     5 *               psListAddBefore, psListRemove, psListRemoveData, psListGet,
     6 *               psListIteratorAlloc, psListIteratorSet, psListGetAndIncrement,
     7 *               psListGetAndDecrement, psListToArray, psArrayToList, psListSort,
     8 *               psListLength
    69 *
    710 * Author: dRob <David.Robbins@mhpcc.hpc.mil>, (C) 2006
    … …  
    1720#include "pstap.h"
    1821
    19 void testHashCreate(void);
    20 //void testHashManip(void);
    21 //void testHashConvert(void);
     22void testListCreate(void);
     23void testListManip(void);
     24void testListConvertSort(void);
    2225
    2326int main(void)
    2427{
    25     plan_tests(25);
    26 
    27     diag("Tests for psHash Functions");
    28 
    29     testHashCreate();
    30     //    testHashManip();
    31     //    testHashConvert();
     28    plan_tests(60);
     29
     30    diag("Tests for psList Functions");
     31
     32    testListCreate();
     33    testListManip();
     34    testListConvertSort();
    3235
    3336    done();
    3437}
    3538
    36 void testHashCreate(void)
     39void testListCreate(void)
    3740{
    38     diag("  >>>Test 1:  psHash Creation Fxns");
    39 
     41    diag("  >>>Test 1:  psList Creation Fxns");
     42    psList *noList = NULL;
     43    psListIterator *noIter = NULL;
     44    psList *list = psListAlloc(NULL);
     45    psMetadata *md = psMetadataAlloc();
     46    psListIterator *iter1 = NULL;
     47    psListIterator *iter2 = NULL;
     48
     49    //Tests for psListAlloc & psMemCheckList
     50    //Return empty list for NULL data input.
     51    {
     52        noList = psListAlloc(NULL);
     53        ok( psListLength(noList) == 0 && psMemCheckList(noList),
     54            "psListAlloc:             return empty list for NULL data input.");
     55    }
     56    //Return allocated list for non-NULL data input.
     57    psFree(noList);
     58    {
     59
     60        noList = psListAlloc(md);
     61        ok( psListLength(noList) == 1,
     62            "psListAlloc:             return correct list for non-NULL data input.");
     63    }
     64    //Make sure psMemCheckList works correctly - return false
     65    {
     66        int j = 2;
     67        ok( !psMemCheckList(&j),
     68            "psMemCheckList:          return false for non-List input.");
     69    }
     70
     71    //Tests for ListIteratorAlloc
     72    //Return NULL for attempt to allocate iterator with NULL list input
     73    {
     74        noIter = psListIteratorAlloc(NULL, 0, true);
     75        ok( noIter == NULL,
     76            "psListIteratorAlloc:     return false for NULL data input.");
     77    }
     78    //Attempt to Allocate a psListIterator with out-of-range location
     79    {
     80        iter1 = psListIteratorAlloc(noList, 10, false);
     81        ok( iter1 == NULL,
     82            "psListIteratorAlloc:     return NULL for out-of-range location.");
     83    }
     84    //Return valid iterator for valid inputs
     85    {
     86        iter1 = psListIteratorAlloc(noList, 0, true);
     87        ok( iter1 != NULL,
     88            "psListIteratorAlloc:     return valid iterator for valid inputs.");
     89    }
     90
     91    //Tests For ListAdd Fxns
     92    //Return false for NULL list input
     93    {
     94        ok( !psListAdd(NULL, 0, md),
     95            "psListAdd:               return false for NULL list input.");
     96    }
     97    //Return false for NULL data input
     98    {
     99        ok( !psListAdd(list, 0, NULL),
     100            "psListAdd:               return false for NULL data input.");
     101    }
     102    //Return false for list with NULL data
     103    {
     104        psFree(list->iterators->data[0]);
     105        list->iterators->data[0] = NULL;
     106        ok( !psListAdd(list, 0, md),
     107            "psListAdd:               return false for list with NULL iterators.");
     108        psFree(list);
     109        list = psListAlloc(md);
     110    }
     111    //Return true for valid inputs - tail location
     112    {
     113        ok( psListAdd(list, 2, md),
     114            "psListAdd:              return true for valid inputs - Tail Location.");
     115    }
     116    //Return true for valid inputs - head location
     117    {
     118        ok( psListAdd(list, 0, md),
     119            "psListAdd:              return true for valid inputs - head Location.");
     120    }
     121
     122    //psListAddAfter Tests
     123    //psListAddAfter - Return false for NULL data input
     124    {
     125        ok( !psListAddAfter(iter1, NULL),
     126            "psListAddAfter:         return false for NULL data input.");
     127    }
     128    //psListAddAfter - Return false for NULL iterator input
     129    {
     130        ok( !psListAddAfter(NULL, md),
     131            "psListAddAfter:         return false for NULL iterator input.");
     132    }
     133    //psListAddAfter - Return false for non-mutable iterator input
     134    {
     135        iter1->mutable = false;
     136        ok( !psListAddAfter(iter1, md),
     137            "psListAddAfter:         return false for non-mutable iterator input.");
     138        iter1->mutable = true;
     139        psFree(iter1);
     140    }
     141    //psListAddAfter - Return false for iterator with NULL cursor
     142    psList *newList = psListAlloc(md);
     143    iter1 = psListIteratorAlloc(newList, 0, true);
     144    psListElem *cursor = iter1->cursor;
     145    {
     146        iter1->cursor = NULL;
     147        ok( !psListAddAfter(iter1, md),
     148            "psListAddAfter:         return false for iterator with headptr but no cursor.");
     149        iter1->cursor = cursor;
     150    }
     151    //Set the iterator to a middle element, then add after
     152    {
     153        iter2 = psListIteratorAlloc(list, 1, true);
     154        ok( psListAddAfter(iter2, md),
     155            "psListAddAfter:         return true for adding a list element to the middle.");
     156    }
     157    //Set the iterator to the head element, then add after a wrong index.  return true
     158    {
     159        if (!psListIteratorSet(iter2, PS_LIST_HEAD) )
     160            printf("\nerror in set\n\n");
     161        ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10;
     162        ok( psListAddAfter(iter2, md),
     163            "psListAddAfter:         return true for adding a list element to the head.");
     164    }
     165    //Return true for adding to an empty list
     166    psFree(noList);
     167    noList = psListAlloc(NULL);
     168    psListIterator *iter3 = psListIteratorAlloc(noList, 0, true);
     169    {
     170        ok( psListAddAfter(iter3, md),
     171            "psListAddAfter:         return true for adding to an empty list.");
     172    }
     173
     174    //psListAddBefore Tests
     175    //psListAddBefore - Return false for NULL data input
     176    {
     177        ok( !psListAddBefore(iter1, NULL),
     178            "psListAddBefore:        return false for NULL data input.");
     179    }
     180    //psListAddBefore - Return false for NULL iterator input
     181    {
     182        ok( !psListAddBefore(NULL, md),
     183            "psListAddBefore:        return false for NULL iterator input.");
     184    }
     185    //psListAddBefore - Return false for non-mutable iterator input
     186    {
     187        iter1->mutable = false;
     188        ok( !psListAddBefore(iter1, md),
     189            "psListAddBefore:        return false for non-mutable iterator input.");
     190        iter1->mutable = true;
     191    }
     192    {
     193        cursor = iter1->cursor;
     194        iter1->cursor = NULL;
     195        ok( !psListAddBefore(iter1, md),
     196            "psListAddBefore:        return false for iterator with headptr but no cursor.");
     197        iter1->cursor = cursor;
     198    }
     199    //Add before a middle list element
     200    {
     201        psListIteratorSet(iter2, -2);
     202        ok( psListAddBefore(iter2, md),
     203            "psListAddBefore:        return true for adding a list element to the middle.");
     204    }
     205    //Set the iterator to the 2nd element, then add after a wrong index.  return true
     206    {
     207        skip_start(  !psListIteratorSet(iter2, 1), 1,
     208                     "Skipping 1 tests because psListIteratorSet failed");
     209        ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10;
     210        ok( psListAddBefore(iter2, md),
     211            "psListAddBefore:        return true for adding a list element to the head.");
     212        skip_end();
     213    }
     214    //Return true for adding to an empty list
     215    {
     216        psFree(noList);
     217        noList = psListAlloc(NULL);
     218        iter3 = psListIteratorAlloc(noList, 0, true);
     219        psFree(iter3);
     220        ok( psListAddBefore(iter3, md),
     221            "psListAddBefore:        return true for adding to an empty list.");
     222    }
     223
     224    //Check the length of a NULL list
     225    {
     226        psList *emptyList = NULL;
     227        ok( psListLength(emptyList) == -1,
     228            "psListLength:           return -1 for NULL input psList.");
     229    }
    40230
    41231    //Check for Memory leaks
    42232    {
     233        psFree(iter2);
     234        psFree(list);
     235        psFree(iter1);
     236        psFree(newList);
     237        psFree(md);
     238        psFree(noList);
    43239        checkMem();
    44240    }
    45241}
    46242
    47 /*
    48     //Return NULL for attempt to sort NULL psArray input.
     243void testListManip(void)
    49244{
    50     psArray *temp = NULL;
    51     temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr);
    52     ok( temp == NULL,
    53         "psArraySort:     return NULL for NULL input psArray.");
     245    diag("  >>>Test 2:  psList Manipulation Fxns");
     246    psMetadata *md = psMetadataAlloc();
     247    psList *emptyList = psListAlloc(NULL);
     248    psList *list = psListAlloc(md);
     249    psSphere *sphere = psSphereAlloc();
     250    psCube *cube = psCubeAlloc();
     251    psArray *array = psArrayAlloc(0);
     252    psListAdd(list, PS_LIST_TAIL, sphere);
     253    psListAdd(list, PS_LIST_TAIL, cube);
     254    psListAdd(list, PS_LIST_TAIL, array);
     255    psListIterator *emptyIter = psListIteratorAlloc(emptyList, 0, true);
     256    psListIterator *iter1 = psListIteratorAlloc(list, PS_LIST_TAIL, true);
     257
     258    //Tests for psListGet
     259    //Return NULL for NULL list input
     260    {
     261        psMetadata *out = NULL;
     262        out = (psMetadata*)psListGet(NULL, PS_LIST_HEAD);
     263        ok( out == NULL,
     264            "psListGet:              return NULL for NULL list input.");
     265    }
     266    //Return NULL for empty list
     267    {
     268        psMetadata *out = NULL;
     269        out = (psMetadata*)psListGet(emptyList, PS_LIST_HEAD);
     270        ok( out == NULL,
     271            "psListGet:              return NULL for empty list.");
     272    }
     273    //Return NULL for out-of-range location
     274    {
     275        psMetadata *out = NULL;
     276        out = (psMetadata*)psListGet(list, -10);
     277        ok( out == NULL,
     278            "psListGet:              return NULL for out-of-range location.");
     279    }
     280    //Return correct head item for valid inputs
     281    {
     282        psMetadata *out = NULL;
     283        out = (psMetadata*)psListGet(list, PS_LIST_HEAD);
     284        ok( out != NULL && psMemCheckMetadata(out),
     285            "psListGet:              return correct head item for valid inputs.");
     286    }
     287
     288    //Tests for psListGetAndIncrement
     289    //Return NULL for NULL iterator input
     290    {
     291        psMetadata *out = NULL;
     292        out = (psMetadata*)psListGetAndIncrement(NULL);
     293        ok( out == NULL,
     294            "psListGetAndIncrement:  return NULL for NULL iterator input.");
     295    }
     296    //Return NULL for empty iterator with offend = false
     297    {
     298        psMetadata *out = NULL;
     299        out = (psMetadata*)psListGetAndIncrement(emptyIter);
     300        ok( out == NULL,
     301            "psListGetAndIncrement:  return NULL for empty iterator input.");
     302    }
     303    //Return NULL for empty iterator with offend = true
     304    {
     305        emptyIter->offEnd = true;
     306        psMetadata *out = NULL;
     307        out = (psMetadata*)psListGetAndIncrement(emptyIter);
     308        ok( out == NULL,
     309            "psListGetAndIncrement:  return NULL for empty iterator input.");
     310        emptyIter->offEnd = false;
     311    }
     312    //Return correct tail item for valid inputs
     313    {
     314        psArray *out = NULL;
     315        out = (psArray*)psListGetAndIncrement(iter1);
     316        ok( out != NULL && psMemCheckArray(out),
     317            "psListGetAndIncrement:  return correct tail item for valid inputs.");
     318    }
     319
     320    //Tests for psListGetAndDecrement
     321    //Return NULL for NULL iterator input
     322    {
     323        psMetadata *out = NULL;
     324        out = (psMetadata*)psListGetAndDecrement(NULL);
     325        ok( out == NULL,
     326            "psListGetAndDecrement:  return NULL for NULL iterator input.");
     327    }
     328    //Return NULL for empty iterator with offend = false
     329    {
     330        psMetadata *out = NULL;
     331        out = (psMetadata*)psListGetAndDecrement(emptyIter);
     332        ok( out == NULL,
     333            "psListGetAndDecrement:  return NULL for empty iterator input.");
     334    }
     335    //Return NULL for empty iterator with offend = true
     336    {
     337        emptyIter->offEnd = true;
     338        psMetadata *out = NULL;
     339        out = (psMetadata*)psListGetAndDecrement(emptyIter);
     340        ok( out == NULL,
     341            "psListGetAndDecrement:  return NULL for empty iterator input.");
     342        emptyIter->offEnd = false;
     343    }
     344    //Return correct tail item for valid inputs
     345    {
     346        psArray *out = NULL;
     347        skip_start(  !psListIteratorSet(iter1, PS_LIST_TAIL), 1,
     348                     "Skipping 1 tests because psListIteratorSet failed");
     349        out = (psArray*)psListGetAndDecrement(iter1);
     350        ok( out != NULL && psMemCheckArray(out),
     351            "psListGetAndDecrement:  return correct tail item for valid inputs.");
     352        skip_end();
     353    }
     354
     355    //Tests for psListRemove
     356    //Return false for NULL list input
     357    {
     358        ok( !psListRemove(NULL, PS_LIST_HEAD),
     359            "psListRemove:           return false for NULL list input.");
     360    }
     361    //Return false for invalid location
     362    {
     363        ok( !psListRemove(list, -10),
     364            "psListRemove:           return false for invalid location.");
     365    }
     366    //Return false for empty list
     367    {
     368        ok( !psListRemove(emptyList, PS_LIST_HEAD),
     369            "psListRemove:           return false for remove from empty list.");
     370    }
     371    //Return true for remove from middle of list
     372    {
     373        ok( psListRemove(list, 2) && list->n == 3,
     374            "psListRemove:           return true for remove from middle of list.");
     375    }
     376    //Return true for remove from head of list
     377    {
     378        ok( psListRemove(list, PS_LIST_HEAD) && list->n ==2,
     379            "psListRemove:           return true for remove from head of list.");
     380    }
     381    //Return true for remove from tail of list
     382    {
     383        ok( psListRemove(list, PS_LIST_TAIL) && list->n == 1,
     384            "psListRemove:           return true for remove from tail of list.");
     385    }
     386    //Tests for psListRemoveData
     387    //Return false for NULL list input
     388    {
     389        ok( !psListRemoveData(NULL, md),
     390            "psListRemoveData:       return false for NULL list input.");
     391    }
     392    //Return false for NULL data input
     393    {
     394        ok( !psListRemoveData(list, NULL),
     395            "psListRemoveData:       return false for NULL data input.");
     396    }
     397    //Return false for non-matching data
     398    {
     399        ok( !psListRemoveData(list, md),
     400            "psListRemoveData:       return false for non-matching data.");
     401    }
     402    //Return false for trying to remove from an empty list
     403    {
     404        ok( !psListRemoveData(emptyList, md),
     405            "psListRemoveData:       return false for trying to remove from an empty list.");
     406    }
     407    //Return true for remove of valid data
     408    psListAdd(list, PS_LIST_HEAD, cube);
     409    psListAdd(list, PS_LIST_HEAD, array);
     410    {
     411        ok( psListRemoveData(list, sphere),
     412            "psListRemoveData:       return true for remove of valid data.");
     413    }
     414
     415    //Check for Memory leaks
     416    {
     417        psFree(md);
     418        psFree(emptyList);
     419        psFree(list);
     420        psFree(sphere);
     421        psFree(cube);
     422        psFree(array);
     423        checkMem();
     424    }
    54425}
    55     //Attempt to reallocate the psArray - smaller
     426
     427void testListConvertSort(void)
    56428{
    57     psS32 *s32 = (psS32*)psAlloc(sizeof(psS32));
    58     *s32 = 1;
    59     psS32 *s32_2 = (psS32*)psAlloc(sizeof(psS32));
    60     *s32_2 = 2;
    61     skip_start(  !psArraySet(a, 0, s32) || !psArraySet(a, 1, s32), 1,
    62                   "Skipping 1 tests because psArraySet failed");
    63     a = psArrayRealloc(a, 1);
    64     *s32_2 = *((psS32*)(a->data[0]));
    65     ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1,
    66         "psArrayRealloc:   return properly reallocated psArray.");
    67     skip_end();
    68     psFree(s32);
    69     psFree(s32_2);
     429    diag("  >>>Test 3:  psList Conversion and Sorting Fxns");
     430    psList *emptyList = psListAlloc(NULL);
     431    psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
     432    *s1 = 2;
     433    psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
     434    *s2 = 3;
     435    psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
     436    *s3 = 1;
     437    psList *list = psListAlloc(s1);
     438    psListAdd(list, PS_LIST_TAIL, s2);
     439    psListAdd(list, PS_LIST_TAIL, s3);
     440    psArray *array = NULL;
     441    psArray *emptyArray = psArrayAlloc(0);
     442    psList *out = NULL;
     443
     444    //Tests for psListToArray
     445    //Return NULL for NULL list input
     446    {
     447        array = psListToArray(NULL);
     448        ok( array == NULL,
     449            "psListToArray:          return NULL for NULL list input.");
     450    }
     451    //Return empty array for empty list input
     452    {
     453        array = psListToArray(emptyList);
     454        ok( array->n == 0 && psMemCheckArray(array),
     455            "psListToArray:          return empty array for empty list input.");
     456        psFree(array);
     457        array = NULL;
     458    }
     459    //Return correct array for valid list input
     460    {
     461        array = psListToArray(list);
     462        ok( array->n == 3 && *((psS32*)(array->data[0])) == 2,
     463            "psListToArray:          return correct array for valid list input.");
     464    }
     465
     466    //Tests for psArrayToList
     467    //Return NULL for NULL array input
     468    {
     469        out = psArrayToList(NULL);
     470        ok( out == NULL,
     471            "psArrayToList:          return NULL for NULL array input.");
     472    }
     473    //Return empty list for empty array input
     474    {
     475        out = psArrayToList(emptyArray);
     476        ok( out->n == 0 && psMemCheckList(out),
     477            "psArrayToList:          return empty list for empty array input.");
     478        psFree(out);
     479        out = NULL;
     480    }
     481    //Return correct list for valid array input
     482    {
     483        out = psArrayToList(array);
     484        ok( out->n == 3 && *((psS32*)psListGet(out, PS_LIST_HEAD)) == 2,
     485            "psArrayToList:          return correct list for valid array input.");
     486    }
     487
     488    //Tests for psListSort
     489    //Return NULL for NULL list input
     490    {
     491        psList *none = NULL;
     492        none = psListSort(none, (psComparePtrFunc)psCompareDescendingS32Ptr);
     493        ok( none == NULL,
     494            "psListSort:             return NULL for NULL list input.");
     495    }
     496    //Return empty list for empty list input
     497    {
     498        emptyList = psListSort(emptyList, (psComparePtrFunc)psCompareDescendingS32Ptr);
     499        ok( emptyList != NULL,
     500            "psListSort:             return empty list for empty list input.");
     501    }
     502    //Return properly sorted list for valid inputs
     503    {
     504        list = psListSort(list, (psComparePtrFunc)psCompareS32Ptr);
     505        ok( *((psS32*)psListGet(list, 0)) == 1 &&  *((psS32*)psListGet(list, 1)) == 2,
     506            "psListSort:             return properly sorted list for valid inputs.");
     507    }
     508    //Return unchanged list for NULL psComparePtrFunc
     509    {
     510        psList *tempList = NULL;
     511        tempList = psListSort(list, NULL);
     512        ok( tempList == list,
     513            "psListSort:             return unchanged list for NULL psComparePtrFunc.");
     514    }
     515
     516
     517    //Check for Memory leaks
     518    {
     519        psFree(array);
     520        psFree(out);
     521        psFree(emptyArray);
     522        psFree(emptyList);
     523        psFree(list);
     524        psFree(s1);
     525        psFree(s2);
     526        psFree(s3);
     527        checkMem();
     528    }
     529
    70530}
    71     //Make sure psMemCheckHash works correctly - return false
    72 {
    73     int j = 2;
    74     ok( !psMemCheckHash(&j),
    75          "psMemCheckHash:       return false for non-Hash input.");
    76 }
    77     //Allocate a hashBucket by inserting a psHash entry - return true
    78     psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true);
    79 */
    80 
Note: See TracChangeset for help on using the changeset viewer.