Index: /trunk/psLib/src/types/psArray.c =================================================================== --- /trunk/psLib/src/types/psArray.c (revision 8590) +++ /trunk/psLib/src/types/psArray.c (revision 8591) @@ -9,6 +9,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.46 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-08-08 23:32:23 $ + * @version $Revision: 1.47 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-08-25 05:26:19 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -37,8 +37,4 @@ static void arrayFree(psArray* psArr) { - if (psArr == NULL) { - return; - } - psArrayElementsFree(psArr); @@ -60,4 +56,9 @@ psArray* psArrayAlloc(long nalloc) { + if (nalloc < 0) { + psError(PS_ERR_BAD_PARAMETER_VALUE, true, + "Can't allocate a psArray of negative size."); + return NULL; + } psArray* psArr = NULL; @@ -78,6 +79,12 @@ long nalloc) { + if (nalloc < 0) { + psError(PS_ERR_BAD_PARAMETER_VALUE, true, + "Can't reallocate a psArray to negative size."); + return in; + } if (in == NULL) { - psError(PS_ERR_BAD_PARAMETER_NULL,true,_("psArrayRealloc must be given a non-NULL psArray to resize.")); + psError(PS_ERR_BAD_PARAMETER_NULL,true, + _("psArrayRealloc must be given a non-NULL psArray to resize.")); return NULL; } else if (in->nalloc != nalloc) { // No need to realloc to same size Index: /trunk/psLib/src/types/psMetadata.c =================================================================== --- /trunk/psLib/src/types/psMetadata.c (revision 8590) +++ /trunk/psLib/src/types/psMetadata.c (revision 8591) @@ -12,6 +12,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.126 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-08-24 03:17:03 $ + * @version $Revision: 1.127 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-08-25 05:26:19 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -1417,5 +1417,8 @@ // XXX : these may need F64, or %g format for output -bool psPolynomial2DtoMD (psMetadata *md, psPolynomial2D *poly, char *format, ...) +bool psPolynomial2DtoMD (psMetadata *md, + psPolynomial2D *poly, + char *format, + ...) { @@ -1451,6 +1454,8 @@ if (poly->mask[nx][ny]) continue; - psMetadataAdd (folder, PS_LIST_TAIL, "VAL_X%02d_Y%02d", PS_DATA_F64, "polynomial coefficient", poly->coeff[nx][ny], nx, ny); - psMetadataAdd (folder, PS_LIST_TAIL, "ERR_X%02d_Y%02d", PS_DATA_F64, "polynomial coefficient error", poly->coeffErr[nx][ny], nx, ny); + psMetadataAdd (folder, PS_LIST_TAIL, "VAL_X%02d_Y%02d", PS_DATA_F64, + "polynomial coefficient", poly->coeff[nx][ny], nx, ny); + psMetadataAdd (folder, PS_LIST_TAIL, "ERR_X%02d_Y%02d", PS_DATA_F64, + "polynomial coefficient error", poly->coeffErr[nx][ny], nx, ny); } } Index: /trunk/psLib/test/types/Makefile.am =================================================================== --- /trunk/psLib/test/types/Makefile.am (revision 8590) +++ /trunk/psLib/test/types/Makefile.am (revision 8591) @@ -35,5 +35,7 @@ tap_psMetadata_copying \ tap_psMetadata_creating \ - tap_psMetadata_manip + tap_psMetadata_manip \ + tap_psMetadata_polynomials \ + tap_psArray_all @@ -85,4 +87,10 @@ tap_psMetadata_manip_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src tap_psMetadata_manip_LDFLAGS = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la + +tap_psMetadata_polynomials_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src +tap_psMetadata_polynomials_LDFLAGS = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la + +tap_psArray_all_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_srcdir)/test/tap/src +tap_psArray_all_LDFLAGS = $(AM_LDFLAGS) $(top_builddir)/test/tap/src/libtap.la check_DATA = \ Index: /trunk/psLib/test/types/tap_psArray_all.c =================================================================== --- /trunk/psLib/test/types/tap_psArray_all.c (revision 8591) +++ /trunk/psLib/test/types/tap_psArray_all.c (revision 8591) @@ -0,0 +1,226 @@ +/** + * C Implementation: tap_psArray_creating + * + * Description: Tests for psArrayAlloc, psArrayRealloc, psMemCheckArray, + * psArrayElementsFree, psArrayLength + * + * + * Author: dRob , (C) 2006 + * + * Copyright: See COPYING file that comes with this distribution + * + */ + +#include "pstap.h" + +void testArrayAllocs(void); +void testArrayAddRemove(void); +void testArraySetGet(void); +void testArraySort(void); + +int main(void) +{ + plan_tests(15); + + diag("Tests for psArray Functions"); + + testArrayAllocs(); + testArrayAddRemove( ); + testArraySetGet( ); + testArraySort(); + + done(); +} + +void testArrayAllocs(void) +{ + diag("\n >>>Test 1: psArrayAlloc, Realloc, & Free Fxns"); + psArray *a = NULL; + + //Return NULL on attempting to allocate a negative size array + { + a = psArrayAlloc(-2); + ok( a == NULL, + "psArrayAlloc: return NULL for negative array-size input."); + } + //Return properly allocated psArray + { + a = psArrayAlloc(0); + ok( a != NULL && psMemCheckArray(a), + "psArrayAlloc: return properly allocated psArray."); + } + //Make sure psMemCheckArray works correctly - return false + { + int j = 2; + ok( !psMemCheckArray(&j), + "psMemCheckArray: return false for non-Array input."); + } + //Now try to reallocate the psArray - bigger + { + a = psArrayRealloc(a, 2); + ok ( psArrayLength(a) == 0 && a->nalloc == 2, + "psArrayRealloc: return properly reallocated psArray."); + } + //Return NULL when trying to reallocate a NULL psArray + { + psArray *temp = NULL; + temp = psArrayRealloc(temp, 1); + ok( temp == NULL, + "psArrayRealloc: return NULL for NULL input psArray."); + } + //Attempt to reallocate the psArray - smaller + { + 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); + } + //Attempt to reallocate the psArray to negative size + { + a = psArrayRealloc(a, -1); + psS32 *s32 = (psS32*)psAlloc(sizeof(psS32)); + *s32 = 2; + *s32 = *((psS32*)(a->data[0])); + ok( a->n == 1 && a->nalloc == 1 && *s32 == 1, + "psArrayRealloc: return same psArray for negative-size input."); + psFree(s32); + } + //Attempt to free a NULL psArray + psArrayElementsFree(NULL); + //Check the length of a NULL array + { + psArray *emptyArray = NULL; + ok( psArrayLength(emptyArray) == -1, + "psArrayLength: return -1 for NULL input psArray."); + } + + //Check for Memory leaks + { + psFree(a); + checkMem(); + } +} + +void testArrayAddRemove(void) +{ + diag("\n >>>Test 2: psArrayAdd & psArrayRemove Fxns"); + psArray *a = psArrayAlloc(0); + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + + //Attempt to add element to NULL psArray. + { + psArray *temp = NULL; + temp = psArrayAdd(temp, 1, (psPtr)s1); + *s3 = *((psS32*)(temp->data[0])); + ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2, + "psArrayAdd: return array with newly added data."); + psFree(temp); + } + //Attempt to add an element to empty array. + { + a = psArrayAdd(a, 1, (psPtr)s1); + *s2 = 666; + *s3 = 212; + a = psArrayAdd(a, 1, s2); + a = psArrayAdd(a, 1, s3); + *s2 = *((psS32*)(a->data[0])); + ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2, + "psArrayAdd: return array with newly added data."); + } + //Setup array with 3 elements to test remove function + //Return false for attempting to remove from a NULL array + { + psArray *temp = NULL; + ok( !psArrayRemove(temp, s2), + "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."); + } + + //Check for Memory leaks + { + psFree(s1); + psFree(s2); + psFree(s3); + psFree(a); + checkMem(); + } + +} + +void testArraySetGet(void) +{ + diag("\n >>>Test 3: psArraySet & psArrayGet Fxns"); + psArray *a = NULL; + + //Check for Memory leaks + { + psFree(a); + checkMem(); + } +} + +void testArraySort(void) +{ + diag("\n >>>Test 4: psArray Sort Function"); + psArray *a = NULL; + a = psArrayAlloc(3); + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + *s2 = 1; + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + *s3 = 3; + psArraySet(a, a->n, (psPtr)s1); + psArraySet(a, a->n, (psPtr)s2); + psArraySet(a, a->n, (psPtr)s3); + psS32 *s4 = (psS32*)psAlloc(sizeof(psS32)); + psS32 *s5 = (psS32*)psAlloc(sizeof(psS32)); + psS32 *s6 = (psS32*)psAlloc(sizeof(psS32)); + + //Return NULL for attempt to sort NULL psArray input. + { + psArray *temp = NULL; + temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr); + ok( temp == NULL, + "psArraySort: return NULL for NULL input psArray."); + } + //Return properly sorted psArray with descending psS32 elements - 3,2,1 + { + a = psArraySort(a, (psComparePtrFunc)psCompareDescendingS32Ptr); + *s4 = *((psS32*)(a->data[0])); + *s5 = *((psS32*)(a->data[1])); + *s6 = *((psS32*)(a->data[2])); + ok( *s4 == 3 && *s5 == 2 && *s6 == 1, + "psArraySort: return properly sorted psArray."); + } + + //Check for Memory leaks + { + psFree(s1); + psFree(s2); + psFree(s3); + psFree(s4); + psFree(s5); + psFree(s6); + psFree(a); + checkMem(); + } + +} + Index: /trunk/psLib/test/types/tap_psMetadata_creating.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_creating.c (revision 8590) +++ /trunk/psLib/test/types/tap_psMetadata_creating.c (revision 8591) @@ -265,9 +265,4 @@ psMetadata *md = NULL; //Attempt to free a null metadata - psMetadata *dummy = psMetadataAlloc(); - md = dummy; - dummy = NULL; - psFree(dummy); - psFree(md); md = psMetadataAlloc(); psMetadata *md1 = psMetadataAlloc(); Index: /trunk/psLib/test/types/tap_psMetadata_polynomials.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 8591) +++ /trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 8591) @@ -0,0 +1,95 @@ +/** + * C Implementation: tap_psMetadata_polynomials + * + * Description: Tests for psPolynomial(2,3,4)D(to/from)MD + * + * + * Author: dRob , (C) 2006 + * + * Copyright: See COPYING file that comes with this distribution + * + */ + +#include "pstap.h" + +void test2Dcase(void); +void test3Dcase(void); +void test4Dcase(void); + +int main(void) +{ + plan_tests(11); + + diag("psPolynomial(2D, 3D, & 4D)(to/from)MD tests"); + + test2Dcase(); + test3Dcase(); + test4Dcase(); + + done(); +} + +void test2Dcase(void) +{ + diag("\n >>>Test 1: psPolynomial2DtoMD & psPolynomial2DfromMD functions"); + psMetadata *md = psMetadataAlloc(); + psMetadata *out = NULL; + psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 2); + psPolynomial2D *polly = NULL; + + + //Return true for valid case + { + // ok( psPolynomial2DtoMD(md, p2d, "%f", ...); + } + + + + + //Check for Memory leaks + { + psFree(p2d); + psFree(polly); + psFree(out); + psFree(md); + checkMem(); + } +} + +void test3Dcase(void) +{ + diag("\n >>>Test 2: psPolynomial3DtoMD & psPolynomial3DfromMD functions"); + psMetadata *md = psMetadataAlloc(); + psMetadata *out = NULL; + + + + + //Check for Memory leaks + { + psFree(out); + psFree(md); + checkMem(); + } +} + +void test4Dcase(void) +{ + diag("\n >>>Test 3: psPolynomial4DtoMD & psPolynomial4DfromMD functions"); + psMetadata *md = psMetadataAlloc(); + psMetadata *out = NULL; + + + + + //Check for Memory leaks + { + psFree(out); + psFree(md); + checkMem(); + } +} + + + +