IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 6500


Ignore:
Timestamp:
Feb 27, 2006, 4:53:03 PM (20 years ago)
Author:
drobbin
Message:

Add Length functions/tests. Modified psPixelsAlloc to set n=0.

Location:
trunk/psLib
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/math/psPolynomial.c

    r6484 r6500  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.144 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-02-24 23:43:15 $
     9*  @version $Revision: 1.145 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-02-28 02:53:02 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    262262        // General case where the Chebyshev poly has 2 or more terms.
    263263        d = psVectorAlloc(nTerms, PS_TYPE_F64);
     264        d->n = d->nalloc;
    264265        if(poly->mask[nTerms-1] == 0) {
    265266            d->data.F64[nTerms-1] = poly->coeff[nTerms-1];

  • trunk/psLib/src/mathtypes/psVector.c

    r6484 r6500  
    99*  @author Robert DeSonia, MHPCC
    1010*
    11 *  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2006-02-24 23:43:15 $
     11*  @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2006-02-28 02:53:03 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    10011001}
    10021002
     1003long psVectorLength(const psVector *vector)
     1004{
     1005    if ( !psMemCheckVector((psVector*)vector) ) {
     1006        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     1007                "Error:  Specified vector is not a valid psVector \n");
     1008        return -1;
     1009    }
     1010    return (vector->n);
     1011}
     1012
     1013

  • trunk/psLib/src/mathtypes/psVector.h

    r6227 r6500  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-01-28 01:12:14 $
     13 *  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-02-28 02:53:03 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    260260);
    261261
     262/** Get the number of elements in use from a specified psVector. (vector.n)
     263 *
     264 *  @return long:       The number of elements in use.
     265 */
     266long psVectorLength(
     267    const psVector *vector             ///< input psVector
     268);
     269
     270
    262271/// @}
    263272

  • trunk/psLib/src/sys/psMemory.c

    r6425 r6500  
    88*  @author Robert Lupton, Princeton University
    99*
    10 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2006-02-14 00:09:27 $
     10*  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2006-02-28 02:53:03 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    828828            return true;
    829829        else {
    830             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     830            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     831                    "Incorrect pointer.  Datatypes do not match.\n");
    831832            break;
    832833        }
    … …  
    835836            return true;
    836837        else {
    837             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    838             break;
    839         }
    840         /*    case PS_DATA_CELL:
    841                 if ( psMemCheckCell(ptr) )
    842                     return true;
    843                 else
    844                 {
    845                     psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    846                     break;
    847                 }
    848             case PS_DATA_CHIP:
    849                 if ( psMemCheckChip(ptr) )
    850                     return true;
    851                 else
    852                 {
    853                     psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    854                     break;
    855                 }
    856         */
     838            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     839                    "Incorrect pointer.  Datatypes do not match.\n");
     840            break;
     841        }
    857842    case PS_DATA_CUBE:
    858843        if ( psMemCheckCube(ptr) )
    859844            return true;
    860845        else {
    861             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    862             break;
    863         }
    864 
    865 
     846            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     847                    "Incorrect pointer.  Datatypes do not match.\n");
     848            break;
     849        }
    866850    case PS_DATA_FITS:
    867851        if ( psMemCheckFits(ptr) )
    868852            return true;
    869853        else {
    870             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    871             break;
    872         }
    873 
     854            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     855                    "Incorrect pointer.  Datatypes do not match.\n");
     856            break;
     857        }
    874858    case PS_DATA_HASH:
    875859        if ( psMemCheckHash(ptr) )
    876860            return true;
    877861        else {
    878             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     862            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     863                    "Incorrect pointer.  Datatypes do not match.\n");
    879864            break;
    880865        }
    … …  
    883868            return true;
    884869        else {
    885             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     870            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     871                    "Incorrect pointer.  Datatypes do not match.\n");
    886872            break;
    887873        }
    … …  
    890876            return true;
    891877        else {
    892             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     878            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     879                    "Incorrect pointer.  Datatypes do not match.\n");
    893880            break;
    894881        }
    … …  
    897884            return true;
    898885        else {
    899             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     886            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     887                    "Incorrect pointer.  Datatypes do not match.\n");
    900888            break;
    901889        }
    … …  
    904892            return true;
    905893        else {
    906             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     894            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     895                    "Incorrect pointer.  Datatypes do not match.\n");
    907896            break;
    908897        }
    … …  
    911900            return true;
    912901        else {
    913             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     902            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     903                    "Incorrect pointer.  Datatypes do not match.\n");
    914904            break;
    915905        }
    … …  
    918908            return true;
    919909        else {
    920             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     910            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     911                    "Incorrect pointer.  Datatypes do not match.\n");
    921912            break;
    922913        }
    … …  
    925916            return true;
    926917        else {
    927             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     918            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     919                    "Incorrect pointer.  Datatypes do not match.\n");
    928920            break;
    929921        }
    … …  
    932924            return true;
    933925        else {
    934             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     926            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     927                    "Incorrect pointer.  Datatypes do not match.\n");
    935928            break;
    936929        }
    … …  
    939932            return true;
    940933        else {
    941             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     934            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     935                    "Incorrect pointer.  Datatypes do not match.\n");
    942936            break;
    943937        }
    … …  
    946940            return true;
    947941        else {
    948             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     942            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     943                    "Incorrect pointer.  Datatypes do not match.\n");
    949944            break;
    950945        }
    … …  
    953948            return true;
    954949        else {
    955             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     950            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     951                    "Incorrect pointer.  Datatypes do not match.\n");
    956952            break;
    957953        }
    … …  
    960956            return true;
    961957        else {
    962             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     958            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     959                    "Incorrect pointer.  Datatypes do not match.\n");
    963960            break;
    964961        }
    … …  
    967964            return true;
    968965        else {
    969             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     966            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     967                    "Incorrect pointer.  Datatypes do not match.\n");
    970968            break;
    971969        }
    … …  
    974972            return true;
    975973        else {
    976             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     974            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     975                    "Incorrect pointer.  Datatypes do not match.\n");
    977976            break;
    978977        }
    … …  
    981980            return true;
    982981        else {
    983             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     982            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     983                    "Incorrect pointer.  Datatypes do not match.\n");
    984984            break;
    985985        }
    … …  
    988988            return true;
    989989        else {
    990             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     990            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     991                    "Incorrect pointer.  Datatypes do not match.\n");
    991992            break;
    992993        }
    … …  
    995996            return true;
    996997        else {
    997             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    998             break;
    999         }
    1000 
    1001         /*    case PS_DATA_READOUT:
    1002                 if ( psMemCheckReadout(ptr) )
    1003                     return true;
    1004                 else
    1005                 {
    1006                     psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    1007                     break;
    1008                 }
    1009 
    1010         *//*    case PS_DATA_REGION:
    1011                 if ( psMemCheckRegion(ptr) )
    1012                     return true;
    1013                 else
    1014                 {
    1015                     psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
    1016                     break;
    1017                 }
    1018         */
     998            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     999                    "Incorrect pointer.  Datatypes do not match.\n");
     1000            break;
     1001        }
    10191002    case PS_DATA_SCALAR:
    10201003        if ( psMemCheckScalar(ptr) )
    10211004            return true;
    10221005        else {
    1023             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1006            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1007                    "Incorrect pointer.  Datatypes do not match.\n");
    10241008            break;
    10251009        }
    … …  
    10281012            return true;
    10291013        else {
    1030             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1014            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1015                    "Incorrect pointer.  Datatypes do not match.\n");
    10311016            break;
    10321017        }
    … …  
    10351020            return true;
    10361021        else {
    1037             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1022            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1023                    "Incorrect pointer.  Datatypes do not match.\n");
    10381024            break;
    10391025        }
    … …  
    10421028            return true;
    10431029        else {
    1044             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1030            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1031                    "Incorrect pointer.  Datatypes do not match.\n");
    10451032            break;
    10461033        }
    … …  
    10491036            return true;
    10501037        else {
    1051             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1038            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1039                    "Incorrect pointer.  Datatypes do not match.\n");
    10521040            break;
    10531041        }
    … …  
    10561044            return true;
    10571045        else {
    1058             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1046            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1047                    "Incorrect pointer.  Datatypes do not match.\n");
    10591048            break;
    10601049        }
    … …  
    10631052            return true;
    10641053        else {
    1065             psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Incorrect pointer.  Datatypes do not match.\n");
     1054            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1055                    "Incorrect pointer.  Datatypes do not match.\n");
    10661056            break;
    10671057        }
    10681058    default:
    1069         psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid datatype specified.\n");
     1059        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     1060                "Invalid datatype specified.\n");
    10701061    }
    10711062    return false;

  • trunk/psLib/src/sys/psMemory.h

    r6419 r6500  
    1212 *  @ingroup MemoryManagement
    1313 *
    14  *  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-02-10 02:44:46 $
     14 *  @version $Revision: 1.53 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-02-28 02:53:03 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii

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

    r6484 r6500  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.42 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-02-24 23:43:15 $
     11 *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-02-28 02:53:03 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    241241    return psMemIncrRefCounter(array->data[position]);
    242242}
     243
     244long psArrayLength(const psArray *array)
     245{
     246    if ( !psMemCheckArray((psArray*)array) ) {
     247        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     248                "Error:  Specified array is not a valid psArray \n");
     249        return -1;
     250    }
     251    return (array->n);
     252}
     253

  • trunk/psLib/src/types/psArray.h

    r5530 r6500  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-11-16 23:06:35 $
     13 *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-02-28 02:53:03 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    160160);
    161161
     162/** Get the number of elements in use from a specified psArray. (array.n)
     163 *
     164 *  @return long:       The number of elements in use.
     165 */
     166long psArrayLength(
     167    const psArray *array               ///< input psArray
     168);
     169
    162170/// @}
    163171

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

    r6425 r6500  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-02-14 00:09:27 $
     8 *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-02-28 02:53:03 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    621621}
    622622
     623long psListLength(const psList *list)
     624{
     625    if ( !psMemCheckList((psList*)list) ) {
     626        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     627                "Error:  Specified list is not a valid psList \n");
     628        return -1;
     629    }
     630    return (list->n);
     631}
     632
     633

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

    r6425 r6500  
    77 *  @ingroup LinkedList
    88 *
    9  *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-02-14 00:09:27 $
     9 *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-02-28 02:53:03 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    232232);
    233233
     234/** Get the number of elements in use from a specified psList. (list.n)
     235 *
     236 *  @return long:       The number of elements in use.
     237 */
     238long psListLength(
     239    const psList *list                 ///< input psList
     240);
     241
     242
    234243/// @} End of DataGroup Functions
    235244

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

    r5530 r6500  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-11-16 23:06:35 $
     9 *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-02-28 02:53:03 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6565        out->data = NULL;
    6666    }
    67     out->n = nalloc;
     67    out->n = 0;
    6868    P_PSPIXELS_SET_NALLOC(out,nalloc);
    6969
    … …  
    409409}
    410410
     411long psPixelsLength(const psPixels *pixels)
     412{
     413    if ( !psMemCheckPixels((psPixels*)pixels) ) {
     414        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     415                "Error:  Specified pixels is not a valid psPixels \n");
     416        return -1;
     417    }
     418    return (pixels->n);
     419}
     420

  • trunk/psLib/src/types/psPixels.h

    r6230 r6500  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-01-28 01:31:44 $
     9 *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-02-28 02:53:03 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    185185);
    186186
     187/** Get the number of elements in use from a specified psPixels. (pixels.n)
     188 *
     189 *  @return long:       The number of elements in use.
     190 */
     191long psPixelsLength(
     192    const psPixels *pixels             ///< input psPixels
     193);
     194
    187195#endif // #ifndef PS_PIXELS_H

  • trunk/psLib/test/astro/tst_psCoord.c

    r6381 r6500  
    66*  @author GLG, MHPCC
    77*
    8 *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2006-02-08 21:30:09 $
     8*  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2006-02-28 02:53:03 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    437437
    438438    input = psPixelsAlloc(2);
     439    input->n = 2;
    439440    input->data[0].x = 1.0;
    440441    input->data[0].y = 1.0;

  • trunk/psLib/test/mathtypes/tst_psVector.c

    r6484 r6500  
    1414 *  @author  Ross Harman, MHPCC
    1515 *
    16  *  @version $Revision: 1.10 $  $Name: not supported by cvs2svn $
    17  *  @date  $Date: 2006-02-24 23:43:16 $
     16 *  @version $Revision: 1.11 $  $Name: not supported by cvs2svn $
     17 *  @date  $Date: 2006-02-28 02:53:03 $
    1818 *
    1919 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3333static psS32 testVectorGetSet(void);
    3434static psS32 testVectorCountPixelMask(void);
     35static psS32 testVectorLength(void);
    3536
    3637testDescription tests[] = {
    … …  
    4445                              {testVectorGetSet,-8,"psVectorGet/Set",0,false},
    4546                              {testVectorCountPixelMask,-9,"psVectorCountPixelMask",0,false},
     47                              {testVectorLength,666,"psVectorLength",0,false},
    4648                              {NULL}
    4749                          };
    … …  
    548550}
    549551
     552psS32 testVectorLength( void )
     553{
     554    psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
     555
     556    if (psVectorLength(vector) != 0) {
     557        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     558                "psVectorLength failed to return the correct length of vector.\n");
     559        return 1;
     560    }
     561    vector->n = 5;
     562    if (psVectorLength(vector) != 5) {
     563        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     564                "psVectorLength failed to return the correct length of vector.\n");
     565        return 2;
     566    }
     567    vector->n++;
     568    if (psVectorLength(vector) != 6) {
     569        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     570                "psVectorLength failed to return the correct length of vector.\n");
     571        return 3;
     572    }
     573    psFree(vector);
     574
     575    psVector *emptyVector = NULL;
     576    psArray *array = psArrayAlloc(5);
     577
     578    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     579    if (psVectorLength(emptyVector) != -1) {
     580        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     581                "psVectorLength failed to return -1 for a NULL input vector.\n");
     582        return 4;
     583    }
     584    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     585    if (psVectorLength((psVector*)array) != -1) {
     586        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     587                "psVectorLength failed to return -1 for an invalid input vector.\n");
     588        return 5;
     589    }
     590    psFree(array);
     591
     592    return 0;
     593}
     594

  • trunk/psLib/test/mathtypes/verified/tst_psVector.stderr

    r6484 r6500  
    108108---> TESTPOINT PASSED (psVector{psVectorCountPixelMask} | tst_psVector.c)
    109109
     110/***************************** TESTPOINT ******************************************\
     111*             TestFile: tst_psVector.c                                             *
     112*            TestPoint: psVector{psVectorLength}                                   *
     113*             TestType: Positive                                                   *
     114\**********************************************************************************/
     115
     116<HOST>|I|testVectorLength
     117    Following should generate error message
     118<HOST>|E|psVectorLength (FILE:LINENO)
     119    Error:  Specified vector is not a valid psVector
     120<HOST>|I|testVectorLength
     121    Following should generate error message
     122<HOST>|E|psVectorLength (FILE:LINENO)
     123    Error:  Specified vector is not a valid psVector
     124
     125---> TESTPOINT PASSED (psVector{psVectorLength} | tst_psVector.c)
     126

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

    r6445 r6500  
    1717 *  @author  Ross Harman, MHPCC
    1818 *
    19  *  @version $Revision: 1.5 $  $Name: not supported by cvs2svn $
    20  *  @date  $Date: 2006-02-17 03:24:46 $
     19 *  @version $Revision: 1.6 $  $Name: not supported by cvs2svn $
     20 *  @date  $Date: 2006-02-28 02:53:03 $
    2121 *
    2222 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5353static psS32 testArrayAdd( void );
    5454static psS32 testArrayGetSet( void );
    55 
     55static psS32 testArrayLength( void );
    5656
    5757testDescription tests[] = {
    … …  
    6060                              {testArrayAdd, 667, "psArrayAdd", 0, false},
    6161                              {testArrayGetSet, 668, "psArrayGetSet", 0, false},
     62                              {testArrayLength, 669, "psArrayLength", 0, false},
    6263                              {NULL}
    6364                          };
    … …  
    464465    if ( !psArraySet(test, 0, p1) )
    465466        fprintf(stderr, "ArraySet failed to set S32 at position 0\n");
     467    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
    466468    if ( psArraySet(test, 10, p1) )
    467469        fprintf(stderr, "ArraySet Improperly set S32 at out of range position\n");
    … …  
    475477    psFree(p2); // free ref from psArrayGet
    476478
     479    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
    477480    if ( psArraySet(test, -6, p3) )
    478481        fprintf(stderr, "ArraySet failed to fail using an out of range negative number\n");
    … …  
    485488    return 0;
    486489}
     490
     491psS32 testArrayLength( void )
     492{
     493    psArray *array = psArrayAlloc(5);
     494
     495    if (psArrayLength(array) != 0) {
     496        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     497                "psArrayLength failed to return the correct length of array.\n");
     498        return 1;
     499    }
     500    array->n = 5;
     501    if (psArrayLength(array) != 5) {
     502        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     503                "psArrayLength failed to return the correct length of array.\n");
     504        return 2;
     505    }
     506    array->n++;
     507    if (psArrayLength(array) != 6) {
     508        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     509                "psArrayLength failed to return the correct length of array.\n");
     510        return 3;
     511    }
     512    psFree(array);
     513
     514    psArray *emptyArray = NULL;
     515    psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
     516
     517    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     518    if (psArrayLength(emptyArray) != -1) {
     519        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     520                "psArrayLength failed to return -1 for a NULL input array.\n");
     521        return 4;
     522    }
     523    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     524    if (psArrayLength((psArray*)vector) != -1) {
     525        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     526                "psArrayLength failed to return -1 for an invalid input array.\n");
     527        return 5;
     528    }
     529    psFree(vector);
     530
     531    return 0;
     532}
     533

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

    r4547 r6500  
    66 *  @author Robert DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-07-13 02:47:01 $
     8 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-02-28 02:53:03 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828static psS32 testListAddAfter(void);
    2929static psS32 testListAddBefore(void);
     30static psS32 testListLength(void);
    3031
    3132testDescription tests[] = {
    … …  
    4041                              {testListAddAfter,811,"psListAddAfter",0,false},
    4142                              {testListAddBefore,811,"psListAddBefore",0,false},
     43                              {testListLength,666,"testListLength",0,false},
    4244                              {NULL}
    4345                          };
    … …  
    12711273    return 0;
    12721274}
     1275
     1276psS32 testListLength( void )
     1277{
     1278    psArray *temp = psArrayAlloc(5);
     1279    psList *list = psListAlloc(temp);
     1280
     1281    if (psListLength(list) != 1) {
     1282        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1283                "psListLength failed to return the correct length of list.\n");
     1284        return 1;
     1285    }
     1286    list->n = 5;
     1287    if (psListLength(list) != 5) {
     1288        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1289                "psListLength failed to return the correct length of list.\n");
     1290        return 2;
     1291    }
     1292    list->n++;
     1293    if (psListLength(list) != 6) {
     1294        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1295                "psListLength failed to return the correct length of list.\n");
     1296        return 3;
     1297    }
     1298    psFree(temp);
     1299    psFree(list);
     1300
     1301    psList *emptyList = NULL;
     1302    psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
     1303
     1304    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     1305    if (psListLength(emptyList) != -1) {
     1306        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1307                "psListLength failed to return -1 for a NULL input list.\n");
     1308        return 4;
     1309    }
     1310    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     1311    if (psListLength((psList*)vector) != -1) {
     1312        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     1313                "psListLength failed to return -1 for an invalid input list.\n");
     1314        return 5;
     1315    }
     1316    psFree(vector);
     1317
     1318    return 0;
     1319}
     1320

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

    r5214 r6500  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.3 $
     7 *  @version $Revision: 1.4 $
    88 *           $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-10-01 00:14:17 $
     9 *  @date $Date: 2006-02-28 02:53:03 $
    1010 *
    1111 *  Copyright 2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2222static int testPixelsConcatenate(void);
    2323static psS32 testPixelsGetSet(void);
     24static psS32 testPixelsLength( void );
    2425
    2526testDescription tests[] = {
    … …  
    3132                              {testPixelsConcatenate,866,"psPixelsConcatenate",0,false},
    3233                              {testPixelsGetSet,867,"psPixelsGet/Set",0,false},
     34                              {testPixelsLength,666,"psPixelsLength",0,false},
    3335                              {NULL}
    3436                          };
    … …  
    8587    p1->data[0].x = 1;
    8688    p1->data[0].y = 2;
    87 
     89    p1->n++;
    8890    if (p1->n != p1->nalloc) {
    8991        psError(PS_ERR_UNKNOWN, true,
    … …  
    113115        p2->data[i].x = i;
    114116        p2->data[i].y = 100+i;
     117        p2->n++;
    115118    }
    116119
    … …  
    140143    // first, tests that reallocing a NULL just allocates
    141144    psPixels* p0 = psPixelsRealloc(NULL,10);
     145    p0->n = 10;
    142146
    143147    if (p0 == NULL) {
    … …  
    168172
    169173    psPixels* p1 = psPixelsRealloc(p0, 20);
     174    //    p1->n = 20;
    170175
    171176    if (p1 != p0) {
    … …  
    205210
    206211    psPixels* p2 = psPixelsRealloc(p1,5);
    207 
     212    p2->n = 5;
    208213    if (p2 != p1) {
    209214        psError(PS_ERR_UNKNOWN, true,
    … …  
    546551}
    547552
     553psS32 testPixelsLength( void )
     554{
     555    psPixels *pixels = psPixelsAlloc(5);
     556
     557    if (psPixelsLength(pixels) != 0) {
     558        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     559                "psPixelsLength failed to return the correct length of pixels.\n");
     560        return 1;
     561    }
     562    pixels->n = 5;
     563    if (psPixelsLength(pixels) != 5) {
     564        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     565                "psPixelsLength failed to return the correct length of pixels.\n");
     566        return 2;
     567    }
     568    pixels->n++;
     569    if (psPixelsLength(pixels) != 6) {
     570        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     571                "psPixelsLength failed to return the correct length of pixels.\n");
     572        return 3;
     573    }
     574    psFree(pixels);
     575
     576    psPixels *emptyPixels = NULL;
     577    psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
     578
     579    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     580    if (psPixelsLength(emptyPixels) != -1) {
     581        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     582                "psPixelsLength failed to return -1 for a NULL input pixels.\n");
     583        return 4;
     584    }
     585    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     586    if (psPixelsLength((psPixels*)vector) != -1) {
     587        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     588                "psPixelsLength failed to return -1 for an invalid input pixels.\n");
     589        return 5;
     590    }
     591    psFree(vector);
     592
     593    return 0;
     594}
     595

  • trunk/psLib/test/types/verified/tst_psArray.stderr

    r6445 r6500  
    225225\**********************************************************************************/
    226226
     227<DATE><TIME>|<HOST>|I|testArrayGetSet
     228    Following should generate error message
    227229<DATE><TIME>|<HOST>|E|psArraySet (FILE:LINENO)
    228230    Specified position, 10, is greater than n+1 of the array, 1.
     231<DATE><TIME>|<HOST>|I|testArrayGetSet
     232    Following should generate error message
    229233<DATE><TIME>|<HOST>|E|psArraySet (FILE:LINENO)
    230234    Invalid position.  Negative number too large
    … …  
    232236---> TESTPOINT PASSED (psArray{psArrayGetSet} | tst_psArray.c)
    233237
     238/***************************** TESTPOINT ******************************************\
     239*             TestFile: tst_psArray.c                                              *
     240*            TestPoint: psArray{psArrayLength}                                     *
     241*             TestType: Positive                                                   *
     242\**********************************************************************************/
     243
     244<DATE><TIME>|<HOST>|I|testArrayLength
     245    Following should generate error message
     246<DATE><TIME>|<HOST>|E|psArrayLength (FILE:LINENO)
     247    Error:  Specified array is not a valid psArray
     248<DATE><TIME>|<HOST>|I|testArrayLength
     249    Following should generate error message
     250<DATE><TIME>|<HOST>|E|psArrayLength (FILE:LINENO)
     251    Error:  Specified array is not a valid psArray
     252
     253---> TESTPOINT PASSED (psArray{psArrayLength} | tst_psArray.c)
     254

  • trunk/psLib/test/types/verified/tst_psList.stderr

    r4547 r6500  
    165165---> TESTPOINT PASSED (psList{psListAddBefore} | tst_psList.c)
    166166
     167/***************************** TESTPOINT ******************************************\
     168*             TestFile: tst_psList.c                                               *
     169*            TestPoint: psList{testListLength}                                     *
     170*             TestType: Positive                                                   *
     171\**********************************************************************************/
     172
     173<DATE><TIME>|<HOST>|I|testListLength
     174    Following should generate error message
     175<DATE><TIME>|<HOST>|E|psListLength (FILE:LINENO)
     176    Error:  Specified list is not a valid psList
     177<DATE><TIME>|<HOST>|I|testListLength
     178    Following should generate error message
     179<DATE><TIME>|<HOST>|E|psListLength (FILE:LINENO)
     180    Error:  Specified list is not a valid psList
     181
     182---> TESTPOINT PASSED (psList{testListLength} | tst_psList.c)
     183

  • trunk/psLib/test/types/verified/tst_psPixels.stderr

    r5114 r6500  
    8484---> TESTPOINT PASSED (psPixels{psPixelsGet/Set} | tst_psPixels.c)
    8585
     86/***************************** TESTPOINT ******************************************\
     87*             TestFile: tst_psPixels.c                                             *
     88*            TestPoint: psPixels{psPixelsLength}                                   *
     89*             TestType: Positive                                                   *
     90\**********************************************************************************/
     91
     92<DATE><TIME>|<HOST>|I|testPixelsLength
     93    Following should generate error message
     94<DATE><TIME>|<HOST>|E|psPixelsLength (FILE:LINENO)
     95    Error:  Specified pixels is not a valid psPixels
     96<DATE><TIME>|<HOST>|I|testPixelsLength
     97    Following should generate error message
     98<DATE><TIME>|<HOST>|E|psPixelsLength (FILE:LINENO)
     99    Error:  Specified pixels is not a valid psPixels
     100
     101---> TESTPOINT PASSED (psPixels{psPixelsLength} | tst_psPixels.c)
     102
Note: See TracChangeset for help on using the changeset viewer.