Index: /trunk/psLib/src/types/psList.c =================================================================== --- /trunk/psLib/src/types/psList.c (revision 9142) +++ /trunk/psLib/src/types/psList.c (revision 9143) @@ -6,6 +6,6 @@ * @author Robert Daniel DeSonia, MHPCC * - * @version $Revision: 1.53 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-10-02 06:05:53 $ + * @version $Revision: 1.54 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-10-03 06:51:47 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -574,10 +574,12 @@ } - if (list->n > 0) { - arr = psArrayAlloc(list->n); - } else { - arr = psArrayAlloc(1); - } - + //XXX: Following is unnecessary as a list->n = 0 should do ArrayAlloc(0) I believe. + /* if (list->n > 0) { + arr = psArrayAlloc(list->n); + } else { + arr = psArrayAlloc(1); + } + */ + arr = psArrayAlloc(list->n); arr->n = list->n; @@ -618,4 +620,9 @@ return NULL; } + if (func == NULL) { + psError(PS_ERR_BAD_PARAMETER_NULL, true, + _("Specified psComparePtrFunc is NULL.")); + return list; + } // convert to indexable vector for use by qsort. arr = psListToArray(list); Index: /trunk/psLib/src/types/psLookupTable.c =================================================================== --- /trunk/psLib/src/types/psLookupTable.c (revision 9142) +++ /trunk/psLib/src/types/psLookupTable.c (revision 9143) @@ -7,6 +7,6 @@ * @author Ross Harman, MHPCC * -* @version $Revision: 1.37 $ $Name: not supported by cvs2svn $ -* @date $Date: 2006-08-26 04:34:28 $ +* @version $Revision: 1.38 $ $Name: not supported by cvs2svn $ +* @date $Date: 2006-10-03 06:51:47 $ * * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii @@ -253,8 +253,4 @@ static void lookupTableFree(psLookupTable* table) { - if (table == NULL) { - return; - } - psFree(table->values); psFree(table->filename); @@ -279,6 +275,4 @@ long indexCol) { - psLookupTable *outTable = NULL; - // Can't read table if you don't know its name PS_ASSERT_PTR_NON_NULL(filename,NULL); @@ -286,4 +280,6 @@ // Can't read table if you don't know its format PS_ASSERT_PTR_NON_NULL(format,NULL); + + psLookupTable *outTable = NULL; // Allocate lookup table Index: /trunk/psLib/test/types/Makefile.am =================================================================== --- /trunk/psLib/test/types/Makefile.am (revision 9142) +++ /trunk/psLib/test/types/Makefile.am (revision 9143) @@ -28,5 +28,6 @@ tap_psHash_all \ tap_psBitSet_all \ - tap_psList_all + tap_psList_all \ + tap_psLookupTable_all if BUILD_TESTS Index: /trunk/psLib/test/types/execute_tap =================================================================== --- /trunk/psLib/test/types/execute_tap (revision 9142) +++ /trunk/psLib/test/types/execute_tap (revision 9143) @@ -17,2 +17,3 @@ ./tap_psBitSet_all ./tap_psList_all +./tap_psLookupTable_all Index: /trunk/psLib/test/types/tap_psArray_all.c =================================================================== --- /trunk/psLib/test/types/tap_psArray_all.c (revision 9142) +++ /trunk/psLib/test/types/tap_psArray_all.c (revision 9143) @@ -24,5 +24,5 @@ int main(void) { - plan_tests(25); + plan_tests(28); diag("Tests for psArray Functions"); @@ -41,9 +41,10 @@ psArray *a = NULL; + //Tests for psArrayAlloc //Return NULL on attempting to allocate a negative size array { a = psArrayAlloc(-2); ok( a == NULL, - "psArrayAlloc: return NULL for negative array-size input."); + "psArrayAlloc: return NULL for negative array-size input."); } //Return properly allocated psArray @@ -51,17 +52,19 @@ a = psArrayAlloc(0); ok( a != NULL && psMemCheckArray(a), - "psArrayAlloc: return properly allocated psArray."); - } + "psArrayAlloc: return properly allocated psArray."); + } + //Tests for psMemCheckArray //Make sure psMemCheckArray works correctly - return false { int j = 2; ok( !psMemCheckArray(&j), - "psMemCheckArray: return false for non-Array input."); - } + "psMemCheckArray: return false for non-Array input."); + } + //Tests for psArrayRealloc //Now try to reallocate the psArray - bigger { a = psArrayRealloc(a, 2); ok ( psArrayLength(a) == 0 && a->nalloc == 2, - "psArrayRealloc: return properly reallocated psArray."); + "psArrayRealloc: return properly reallocated psArray."); } //Return NULL when trying to reallocate a NULL psArray @@ -70,5 +73,5 @@ temp = psArrayRealloc(temp, 1); ok( temp == NULL, - "psArrayRealloc: return NULL for NULL input psArray."); + "psArrayRealloc: return NULL for NULL input psArray."); } //Attempt to reallocate the psArray - smaller @@ -83,5 +86,5 @@ *s32_2 = *((psS32*)(a->data[0])); ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1, - "psArrayRealloc: return properly reallocated psArray."); + "psArrayRealloc: return properly reallocated psArray."); skip_end(); psFree(s32); @@ -95,7 +98,8 @@ *s32 = *((psS32*)(a->data[0])); ok( a->n == 1 && a->nalloc == 1 && *s32 == 1, - "psArrayRealloc: return same psArray for negative-size input."); + "psArrayRealloc: return same psArray for negative-size input."); psFree(s32); } + //Attempt to free a NULL psArray psArrayElementsFree(NULL); @@ -104,5 +108,5 @@ psArray *emptyArray = NULL; ok( psArrayLength(emptyArray) == -1, - "psArrayLength: return -1 for NULL input psArray."); + "psArrayLength: return -1 for NULL input psArray."); } @@ -123,4 +127,5 @@ psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + //Tests for psArrayAdd //Attempt to add element to NULL psArray. { @@ -129,5 +134,5 @@ *s3 = *((psS32*)(temp->data[0])); ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2, - "psArrayAdd: return array with newly added data."); + "psArrayAdd: return array with newly added data."); psFree(temp); } @@ -141,6 +146,8 @@ *s2 = *((psS32*)(a->data[0])); ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2, - "psArrayAdd: return array with newly added data."); - } + "psArrayAdd: return array with newly added data."); + } + + //Tests for psArrayRemove //Setup array with 3 elements to test remove function //Return false for attempting to remove from a NULL array @@ -148,10 +155,27 @@ psArray *temp = NULL; ok( !psArrayRemove(temp, s2), - "psArrayRemove: return false for NULL input psArray."); + "psArrayRemove: return false for NULL input psArray."); } //Return true for successful removal { ok( psArrayRemove(a, s2) && a->n == 2, - "psArrayRemove: return true for successful removal."); + "psArrayRemove: return true for successful removal."); + } + + //Tests for psArrayRemoveByPos + //Return false for NULL array input + { + ok( !psArrayRemoveByPos(NULL, 0), + "psArrayRemoveByPos: return false for NULL input psArray."); + } + //Return false for out-of-range index + { + ok( !psArrayRemoveByPos(a, 5), + "psArrayRemoveByPos: return false for out-of-range location."); + } + //Return true for successful removal + { + ok( psArrayRemoveByPos(a, 1) && a->n == 1, + "psArrayRemoveByPos: return true for successful removal."); } @@ -179,8 +203,9 @@ *s3 = 3; + //Tests for psArraySet //Return false for trying to set a NULL psArray { ok( !psArraySet(a, 0, (psPtr)s1), - "psArraySet: return false for NULL input psArray."); + "psArraySet: return false for NULL input psArray."); } //Return false for trying to set an invalid position @@ -188,5 +213,5 @@ { ok( !psArraySet(a, 2, (psPtr)s1), - "psArraySet: return false for invalid input position."); + "psArraySet: return false for invalid input position."); } //Return false for trying to set nalloc position @@ -194,10 +219,10 @@ { ok( !psArraySet(a, a->nalloc, (psPtr)s2), - "psArraySet: return false for out-of-range position."); + "psArraySet: return false for out-of-range position."); } //Return false for an invalid position (-2 = out-of-range neg. index) { ok( !psArraySet(a, -2, (psPtr)s2), - "psArraySet: return false for out-of-range negative position."); + "psArraySet: return false for out-of-range negative position."); } //Return true for set to a->n position (< nalloc) @@ -205,5 +230,5 @@ { ok( psArraySet(a, a->n, (psPtr)s2) && a->n == 2, - "psArraySet: return true for valid input position."); + "psArraySet: return true for valid input position."); } //Return true for a negative index input @@ -211,7 +236,8 @@ ok( psArraySet(a, -2, (psPtr)s3) && a->n == 2 && *((psS32*)(a->data[0])) == 3, - "psArraySet: return true for valid negative input position."); - } - + "psArraySet: return true for valid negative input position."); + } + + //Tests for psArrayGet //Return NULL for NULL array input psS32 *s4 = NULL; @@ -219,5 +245,5 @@ s4 = (psS32*)psArrayGet(b, 0); ok( s4 == NULL, - "psArrayGet: return NULL for NULL input psArray."); + "psArrayGet: return NULL for NULL input psArray."); } //Return NULL for an out-of-range index @@ -225,5 +251,5 @@ s4 = (psS32*)psArrayGet(a, a->n); ok( s4 == NULL, - "psArrayGet: return NULL for out-of-range position."); + "psArrayGet: return NULL for out-of-range position."); } //Return NULL for an out-of-range negative index @@ -231,5 +257,5 @@ s4 = (psS32*)psArrayGet(a, -1-a->n); ok( s4 == NULL, - "psArrayGet: return NULL for out-of-range negative position."); + "psArrayGet: return NULL for out-of-range negative position."); } //Return valid case @@ -237,5 +263,5 @@ s4 = (psS32*)psArrayGet(a, 1); ok( *s4 == 1, - "psArrayGet: return correct value for valid position."); + "psArrayGet: return correct value for valid position."); } @@ -268,4 +294,5 @@ psS32 *s6 = (psS32*)psAlloc(sizeof(psS32)); + //Tests for psArraySort //Return NULL for attempt to sort NULL psArray input. { @@ -273,5 +300,5 @@ temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr); ok( temp == NULL, - "psArraySort: return NULL for NULL input psArray."); + "psArraySort: return NULL for NULL input psArray."); } //Return properly sorted psArray with descending psS32 elements - 3,2,1 @@ -282,5 +309,5 @@ *s6 = *((psS32*)(a->data[2])); ok( *s4 == 3 && *s5 == 2 && *s6 == 1, - "psArraySort: return properly sorted psArray."); + "psArraySort: return properly sorted psArray."); } Index: /trunk/psLib/test/types/tap_psBitSet_all.c =================================================================== --- /trunk/psLib/test/types/tap_psBitSet_all.c (revision 9142) +++ /trunk/psLib/test/types/tap_psBitSet_all.c (revision 9143) @@ -39,5 +39,5 @@ psBitSet *bs = NULL; - //Return NULL for attempt to sort NULL psArray input. + //Return NULL for attempt to Allocate BitSet of negative size. { noBits = psBitSetAlloc(-1); Index: /trunk/psLib/test/types/tap_psList_all.c =================================================================== --- /trunk/psLib/test/types/tap_psList_all.c (revision 9142) +++ /trunk/psLib/test/types/tap_psList_all.c (revision 9143) @@ -1,7 +1,10 @@ /** - * C Implementation: tap_psHash_all + * C Implementation: tap_psList_all * - * Description: Tests for psHashAlloc, psHashAdd, psMemCheckHash, psHashLookup, - * psHashRemove, psHashKeyList, psHashToArray + * Description: Tests for psListAlloc, psListAdd, psMemCheckList, psListAddAfter, + * psListAddBefore, psListRemove, psListRemoveData, psListGet, + * psListIteratorAlloc, psListIteratorSet, psListGetAndIncrement, + * psListGetAndDecrement, psListToArray, psArrayToList, psListSort, + * psListLength * * Author: dRob , (C) 2006 @@ -17,64 +20,511 @@ #include "pstap.h" -void testHashCreate(void); -//void testHashManip(void); -//void testHashConvert(void); +void testListCreate(void); +void testListManip(void); +void testListConvertSort(void); int main(void) { - plan_tests(25); - - diag("Tests for psHash Functions"); - - testHashCreate(); - // testHashManip(); - // testHashConvert(); + plan_tests(60); + + diag("Tests for psList Functions"); + + testListCreate(); + testListManip(); + testListConvertSort(); done(); } -void testHashCreate(void) +void testListCreate(void) { - diag(" >>>Test 1: psHash Creation Fxns"); - + diag(" >>>Test 1: psList Creation Fxns"); + psList *noList = NULL; + psListIterator *noIter = NULL; + psList *list = psListAlloc(NULL); + psMetadata *md = psMetadataAlloc(); + psListIterator *iter1 = NULL; + psListIterator *iter2 = NULL; + + //Tests for psListAlloc & psMemCheckList + //Return empty list for NULL data input. + { + noList = psListAlloc(NULL); + ok( psListLength(noList) == 0 && psMemCheckList(noList), + "psListAlloc: return empty list for NULL data input."); + } + //Return allocated list for non-NULL data input. + psFree(noList); + { + + noList = psListAlloc(md); + ok( psListLength(noList) == 1, + "psListAlloc: return correct list for non-NULL data input."); + } + //Make sure psMemCheckList works correctly - return false + { + int j = 2; + ok( !psMemCheckList(&j), + "psMemCheckList: return false for non-List input."); + } + + //Tests for ListIteratorAlloc + //Return NULL for attempt to allocate iterator with NULL list input + { + noIter = psListIteratorAlloc(NULL, 0, true); + ok( noIter == NULL, + "psListIteratorAlloc: return false for NULL data input."); + } + //Attempt to Allocate a psListIterator with out-of-range location + { + iter1 = psListIteratorAlloc(noList, 10, false); + ok( iter1 == NULL, + "psListIteratorAlloc: return NULL for out-of-range location."); + } + //Return valid iterator for valid inputs + { + iter1 = psListIteratorAlloc(noList, 0, true); + ok( iter1 != NULL, + "psListIteratorAlloc: return valid iterator for valid inputs."); + } + + //Tests For ListAdd Fxns + //Return false for NULL list input + { + ok( !psListAdd(NULL, 0, md), + "psListAdd: return false for NULL list input."); + } + //Return false for NULL data input + { + ok( !psListAdd(list, 0, NULL), + "psListAdd: return false for NULL data input."); + } + //Return false for list with NULL data + { + psFree(list->iterators->data[0]); + list->iterators->data[0] = NULL; + ok( !psListAdd(list, 0, md), + "psListAdd: return false for list with NULL iterators."); + psFree(list); + list = psListAlloc(md); + } + //Return true for valid inputs - tail location + { + ok( psListAdd(list, 2, md), + "psListAdd: return true for valid inputs - Tail Location."); + } + //Return true for valid inputs - head location + { + ok( psListAdd(list, 0, md), + "psListAdd: return true for valid inputs - head Location."); + } + + //psListAddAfter Tests + //psListAddAfter - Return false for NULL data input + { + ok( !psListAddAfter(iter1, NULL), + "psListAddAfter: return false for NULL data input."); + } + //psListAddAfter - Return false for NULL iterator input + { + ok( !psListAddAfter(NULL, md), + "psListAddAfter: return false for NULL iterator input."); + } + //psListAddAfter - Return false for non-mutable iterator input + { + iter1->mutable = false; + ok( !psListAddAfter(iter1, md), + "psListAddAfter: return false for non-mutable iterator input."); + iter1->mutable = true; + psFree(iter1); + } + //psListAddAfter - Return false for iterator with NULL cursor + psList *newList = psListAlloc(md); + iter1 = psListIteratorAlloc(newList, 0, true); + psListElem *cursor = iter1->cursor; + { + iter1->cursor = NULL; + ok( !psListAddAfter(iter1, md), + "psListAddAfter: return false for iterator with headptr but no cursor."); + iter1->cursor = cursor; + } + //Set the iterator to a middle element, then add after + { + iter2 = psListIteratorAlloc(list, 1, true); + ok( psListAddAfter(iter2, md), + "psListAddAfter: return true for adding a list element to the middle."); + } + //Set the iterator to the head element, then add after a wrong index. return true + { + if (!psListIteratorSet(iter2, PS_LIST_HEAD) ) + printf("\nerror in set\n\n"); + ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10; + ok( psListAddAfter(iter2, md), + "psListAddAfter: return true for adding a list element to the head."); + } + //Return true for adding to an empty list + psFree(noList); + noList = psListAlloc(NULL); + psListIterator *iter3 = psListIteratorAlloc(noList, 0, true); + { + ok( psListAddAfter(iter3, md), + "psListAddAfter: return true for adding to an empty list."); + } + + //psListAddBefore Tests + //psListAddBefore - Return false for NULL data input + { + ok( !psListAddBefore(iter1, NULL), + "psListAddBefore: return false for NULL data input."); + } + //psListAddBefore - Return false for NULL iterator input + { + ok( !psListAddBefore(NULL, md), + "psListAddBefore: return false for NULL iterator input."); + } + //psListAddBefore - Return false for non-mutable iterator input + { + iter1->mutable = false; + ok( !psListAddBefore(iter1, md), + "psListAddBefore: return false for non-mutable iterator input."); + iter1->mutable = true; + } + { + cursor = iter1->cursor; + iter1->cursor = NULL; + ok( !psListAddBefore(iter1, md), + "psListAddBefore: return false for iterator with headptr but no cursor."); + iter1->cursor = cursor; + } + //Add before a middle list element + { + psListIteratorSet(iter2, -2); + ok( psListAddBefore(iter2, md), + "psListAddBefore: return true for adding a list element to the middle."); + } + //Set the iterator to the 2nd element, then add after a wrong index. return true + { + skip_start( !psListIteratorSet(iter2, 1), 1, + "Skipping 1 tests because psListIteratorSet failed"); + ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10; + ok( psListAddBefore(iter2, md), + "psListAddBefore: return true for adding a list element to the head."); + skip_end(); + } + //Return true for adding to an empty list + { + psFree(noList); + noList = psListAlloc(NULL); + iter3 = psListIteratorAlloc(noList, 0, true); + psFree(iter3); + ok( psListAddBefore(iter3, md), + "psListAddBefore: return true for adding to an empty list."); + } + + //Check the length of a NULL list + { + psList *emptyList = NULL; + ok( psListLength(emptyList) == -1, + "psListLength: return -1 for NULL input psList."); + } //Check for Memory leaks { + psFree(iter2); + psFree(list); + psFree(iter1); + psFree(newList); + psFree(md); + psFree(noList); checkMem(); } } -/* - //Return NULL for attempt to sort NULL psArray input. +void testListManip(void) { - psArray *temp = NULL; - temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr); - ok( temp == NULL, - "psArraySort: return NULL for NULL input psArray."); + diag(" >>>Test 2: psList Manipulation Fxns"); + psMetadata *md = psMetadataAlloc(); + psList *emptyList = psListAlloc(NULL); + psList *list = psListAlloc(md); + psSphere *sphere = psSphereAlloc(); + psCube *cube = psCubeAlloc(); + psArray *array = psArrayAlloc(0); + psListAdd(list, PS_LIST_TAIL, sphere); + psListAdd(list, PS_LIST_TAIL, cube); + psListAdd(list, PS_LIST_TAIL, array); + psListIterator *emptyIter = psListIteratorAlloc(emptyList, 0, true); + psListIterator *iter1 = psListIteratorAlloc(list, PS_LIST_TAIL, true); + + //Tests for psListGet + //Return NULL for NULL list input + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(NULL, PS_LIST_HEAD); + ok( out == NULL, + "psListGet: return NULL for NULL list input."); + } + //Return NULL for empty list + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(emptyList, PS_LIST_HEAD); + ok( out == NULL, + "psListGet: return NULL for empty list."); + } + //Return NULL for out-of-range location + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(list, -10); + ok( out == NULL, + "psListGet: return NULL for out-of-range location."); + } + //Return correct head item for valid inputs + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(list, PS_LIST_HEAD); + ok( out != NULL && psMemCheckMetadata(out), + "psListGet: return correct head item for valid inputs."); + } + + //Tests for psListGetAndIncrement + //Return NULL for NULL iterator input + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndIncrement(NULL); + ok( out == NULL, + "psListGetAndIncrement: return NULL for NULL iterator input."); + } + //Return NULL for empty iterator with offend = false + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndIncrement(emptyIter); + ok( out == NULL, + "psListGetAndIncrement: return NULL for empty iterator input."); + } + //Return NULL for empty iterator with offend = true + { + emptyIter->offEnd = true; + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndIncrement(emptyIter); + ok( out == NULL, + "psListGetAndIncrement: return NULL for empty iterator input."); + emptyIter->offEnd = false; + } + //Return correct tail item for valid inputs + { + psArray *out = NULL; + out = (psArray*)psListGetAndIncrement(iter1); + ok( out != NULL && psMemCheckArray(out), + "psListGetAndIncrement: return correct tail item for valid inputs."); + } + + //Tests for psListGetAndDecrement + //Return NULL for NULL iterator input + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndDecrement(NULL); + ok( out == NULL, + "psListGetAndDecrement: return NULL for NULL iterator input."); + } + //Return NULL for empty iterator with offend = false + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndDecrement(emptyIter); + ok( out == NULL, + "psListGetAndDecrement: return NULL for empty iterator input."); + } + //Return NULL for empty iterator with offend = true + { + emptyIter->offEnd = true; + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndDecrement(emptyIter); + ok( out == NULL, + "psListGetAndDecrement: return NULL for empty iterator input."); + emptyIter->offEnd = false; + } + //Return correct tail item for valid inputs + { + psArray *out = NULL; + skip_start( !psListIteratorSet(iter1, PS_LIST_TAIL), 1, + "Skipping 1 tests because psListIteratorSet failed"); + out = (psArray*)psListGetAndDecrement(iter1); + ok( out != NULL && psMemCheckArray(out), + "psListGetAndDecrement: return correct tail item for valid inputs."); + skip_end(); + } + + //Tests for psListRemove + //Return false for NULL list input + { + ok( !psListRemove(NULL, PS_LIST_HEAD), + "psListRemove: return false for NULL list input."); + } + //Return false for invalid location + { + ok( !psListRemove(list, -10), + "psListRemove: return false for invalid location."); + } + //Return false for empty list + { + ok( !psListRemove(emptyList, PS_LIST_HEAD), + "psListRemove: return false for remove from empty list."); + } + //Return true for remove from middle of list + { + ok( psListRemove(list, 2) && list->n == 3, + "psListRemove: return true for remove from middle of list."); + } + //Return true for remove from head of list + { + ok( psListRemove(list, PS_LIST_HEAD) && list->n ==2, + "psListRemove: return true for remove from head of list."); + } + //Return true for remove from tail of list + { + ok( psListRemove(list, PS_LIST_TAIL) && list->n == 1, + "psListRemove: return true for remove from tail of list."); + } + //Tests for psListRemoveData + //Return false for NULL list input + { + ok( !psListRemoveData(NULL, md), + "psListRemoveData: return false for NULL list input."); + } + //Return false for NULL data input + { + ok( !psListRemoveData(list, NULL), + "psListRemoveData: return false for NULL data input."); + } + //Return false for non-matching data + { + ok( !psListRemoveData(list, md), + "psListRemoveData: return false for non-matching data."); + } + //Return false for trying to remove from an empty list + { + ok( !psListRemoveData(emptyList, md), + "psListRemoveData: return false for trying to remove from an empty list."); + } + //Return true for remove of valid data + psListAdd(list, PS_LIST_HEAD, cube); + psListAdd(list, PS_LIST_HEAD, array); + { + ok( psListRemoveData(list, sphere), + "psListRemoveData: return true for remove of valid data."); + } + + //Check for Memory leaks + { + psFree(md); + psFree(emptyList); + psFree(list); + psFree(sphere); + psFree(cube); + psFree(array); + checkMem(); + } } - //Attempt to reallocate the psArray - smaller + +void testListConvertSort(void) { - psS32 *s32 = (psS32*)psAlloc(sizeof(psS32)); - *s32 = 1; - psS32 *s32_2 = (psS32*)psAlloc(sizeof(psS32)); - *s32_2 = 2; - skip_start( !psArraySet(a, 0, s32) || !psArraySet(a, 1, s32), 1, - "Skipping 1 tests because psArraySet failed"); - a = psArrayRealloc(a, 1); - *s32_2 = *((psS32*)(a->data[0])); - ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1, - "psArrayRealloc: return properly reallocated psArray."); - skip_end(); - psFree(s32); - psFree(s32_2); + diag(" >>>Test 3: psList Conversion and Sorting Fxns"); + psList *emptyList = psListAlloc(NULL); + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + *s2 = 3; + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + *s3 = 1; + psList *list = psListAlloc(s1); + psListAdd(list, PS_LIST_TAIL, s2); + psListAdd(list, PS_LIST_TAIL, s3); + psArray *array = NULL; + psArray *emptyArray = psArrayAlloc(0); + psList *out = NULL; + + //Tests for psListToArray + //Return NULL for NULL list input + { + array = psListToArray(NULL); + ok( array == NULL, + "psListToArray: return NULL for NULL list input."); + } + //Return empty array for empty list input + { + array = psListToArray(emptyList); + ok( array->n == 0 && psMemCheckArray(array), + "psListToArray: return empty array for empty list input."); + psFree(array); + array = NULL; + } + //Return correct array for valid list input + { + array = psListToArray(list); + ok( array->n == 3 && *((psS32*)(array->data[0])) == 2, + "psListToArray: return correct array for valid list input."); + } + + //Tests for psArrayToList + //Return NULL for NULL array input + { + out = psArrayToList(NULL); + ok( out == NULL, + "psArrayToList: return NULL for NULL array input."); + } + //Return empty list for empty array input + { + out = psArrayToList(emptyArray); + ok( out->n == 0 && psMemCheckList(out), + "psArrayToList: return empty list for empty array input."); + psFree(out); + out = NULL; + } + //Return correct list for valid array input + { + out = psArrayToList(array); + ok( out->n == 3 && *((psS32*)psListGet(out, PS_LIST_HEAD)) == 2, + "psArrayToList: return correct list for valid array input."); + } + + //Tests for psListSort + //Return NULL for NULL list input + { + psList *none = NULL; + none = psListSort(none, (psComparePtrFunc)psCompareDescendingS32Ptr); + ok( none == NULL, + "psListSort: return NULL for NULL list input."); + } + //Return empty list for empty list input + { + emptyList = psListSort(emptyList, (psComparePtrFunc)psCompareDescendingS32Ptr); + ok( emptyList != NULL, + "psListSort: return empty list for empty list input."); + } + //Return properly sorted list for valid inputs + { + list = psListSort(list, (psComparePtrFunc)psCompareS32Ptr); + ok( *((psS32*)psListGet(list, 0)) == 1 && *((psS32*)psListGet(list, 1)) == 2, + "psListSort: return properly sorted list for valid inputs."); + } + //Return unchanged list for NULL psComparePtrFunc + { + psList *tempList = NULL; + tempList = psListSort(list, NULL); + ok( tempList == list, + "psListSort: return unchanged list for NULL psComparePtrFunc."); + } + + + //Check for Memory leaks + { + psFree(array); + psFree(out); + psFree(emptyArray); + psFree(emptyList); + psFree(list); + psFree(s1); + psFree(s2); + psFree(s3); + checkMem(); + } + } - //Make sure psMemCheckHash works correctly - return false -{ - int j = 2; - ok( !psMemCheckHash(&j), - "psMemCheckHash: return false for non-Hash input."); -} - //Allocate a hashBucket by inserting a psHash entry - return true - psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true); -*/ -