IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2669


Ignore:
Timestamp:
Dec 8, 2004, 2:47:20 PM (22 years ago)
Author:
evanalst
Message:

Add additional test case to increase test coverage.

Location:
trunk/psLib/test/collections
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/collections/tst_psVectorSort_01.c

    r2392 r2669  
    44 *
    55 *  This test driver contains the following tests for psVectorSort test point 1:
    6  *     A)  Create float vectors
    7  *     B)  Sort input float vector and put results into output float vector
     6 *     A)  Sort input vector to output vector for all types
     7 *     B)  Sort input float vector into itself
     8 *     C)  Attempt to sort vector with invalid type (i.e. PS_TYPE_BOOL)
     9 *     D)  Sort input vector with zero items
    810 *     C)  Free float vectors
    911 *
    1012 *  @author  Ross Harman, MHPCC
    1113 *
    12  *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
    13  *  @date  $Date: 2004-11-22 21:07:42 $
     14 *  @version $Revision: 1.5 $  $Name: not supported by cvs2svn $
     15 *  @date  $Date: 2004-12-09 00:47:20 $
    1416 *
    1517 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2022#include "psTest.h"
    2123
     24#define tstVectorSortByType(datatype,value)   \
     25in = psVectorAlloc(7,PS_TYPE_##datatype); \
     26in->n = 7;  \
     27out = psVectorAlloc(7,PS_TYPE_##datatype); \
     28out->n = 7;  \
     29in->data.datatype[0] = 7+value; \
     30in->data.datatype[1] = 9+value; \
     31in->data.datatype[2] = 3+value; \
     32in->data.datatype[3] = 1+value; \
     33in->data.datatype[4] = 5+value; \
     34in->data.datatype[5] = 5+value; \
     35in->data.datatype[6] = 0+value; \
     36tempVec = out; \
     37out = psVectorSort(out, in); \
     38if(tempVec != out) {  \
     39    psError(PS_ERR_UNKNOWN,true,"Return value not equal to orignal output argument passed to function"); \
     40    return 5; \
     41} \
     42if(out->data.datatype[0] != in->data.datatype[6]) { \
     43    psError(PS_ERR_UNKNOWN,true,"Improper sort out[0] type %s",#datatype); \
     44    return 10; \
     45} \
     46if(out->data.datatype[1] != in->data.datatype[3]) { \
     47    psError(PS_ERR_UNKNOWN,true,"Improper sort out[1] type %s",#datatype); \
     48    return 20; \
     49} \
     50if(out->data.datatype[2] != in->data.datatype[2]) { \
     51    psError(PS_ERR_UNKNOWN,true,"Improper sort out[2] type %s",#datatype); \
     52    return 30; \
     53} \
     54if(out->data.datatype[3] != in->data.datatype[4]) { \
     55    psError(PS_ERR_UNKNOWN,true,"Improper sort out[3] type %s",#datatype); \
     56    return 40; \
     57} \
     58if(out->data.datatype[4] != in->data.datatype[5]) { \
     59    psError(PS_ERR_UNKNOWN,true,"Improper sort out[4] %s",#datatype); \
     60    return 50; \
     61} \
     62if(out->data.datatype[5] != in->data.datatype[0]) { \
     63    psError(PS_ERR_UNKNOWN,true,"Improper sort out[5] %s",#datatype); \
     64    return 60; \
     65} \
     66if(out->data.datatype[6] != in->data.datatype[1]) { \
     67    psError(PS_ERR_UNKNOWN,true,"Improper sort out[6] %s",#datatype); \
     68    return 70; \
     69} \
     70psFree(in); \
     71psFree(out);
     72
     73
     74
    2275psS32 main(psS32 argc,
    2376           char* argv[])
    … …  
    2780    psVector *tempVec = NULL;
    2881
     82    // Test A - Verify the sort for all supported types
     83    printPositiveTestHeader(stdout,"psVectorSort","Sort all types");
     84    tstVectorSortByType(S8,0);
     85    tstVectorSortByType(S16,1);
     86    tstVectorSortByType(S32,2);
     87    tstVectorSortByType(S64,3);
     88    tstVectorSortByType(U8,4);
     89    tstVectorSortByType(U16,5);
     90    tstVectorSortByType(U32,6);
     91    tstVectorSortByType(U64,7);
     92    tstVectorSortByType(F32,8);
     93    tstVectorSortByType(F64,9);
     94    printFooter(stdout,"psVectorSort","Sort all types",true);
    2995
    30     // Test A - Create float vectors
    31     printPositiveTestHeader(stdout,"psVectorSort", "Create float vectors");
     96    // Test B - Sort input vector into itself
     97    printPositiveTestHeader(stdout,"psVectorSort", "Sort input float vector into itself");
    3298    in = psVectorAlloc(7, PS_TYPE_F32);
    3399    in->n = 7;
    34     out = psVectorAlloc(7, PS_TYPE_F32);
    35     out->n = 7;
    36100    in->data.F32[0] = 7.0f;
    37101    in->data.F32[1] = 9.0f;
    … …  
    41105    in->data.F32[5] = 5.0f;
    42106    in->data.F32[6] = -20.0f;
    43     for(psS32 i=0; i<7; i++) {
    44         printf("vec[%d] = %f\n", i, in->data.F32[i]);
     107    in = psVectorSort(in, in);
     108    if(in->data.F32[0] != -20.0f) {
     109        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[0]");
     110        return 100;
    45111    }
    46     printFooter(stdout, "psVectorSort", "Create float vectors", true);
    47 
    48 
    49     // Test B - Sort input float vector and put results into output float vector
    50     printPositiveTestHeader(stdout,"psVectorSort", "Sort float vector");
    51     tempVec = out;
    52     out = psVectorSort(out, in);
    53     for(psS32 i=0; i<7; i++) {
    54         printf("vec[%d] = %f\n", i, out->data.F32[i]);
     112    if(in->data.F32[1] != 1.0f) {
     113        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[1]");
     114        return 200;
    55115    }
    56     if(out != tempVec) {
    57         printf("Error: Return pointer not equal to output argument pointer\n");
     116    if(in->data.F32[2] != 3.0f) {
     117        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[2]");
     118        return 300;
    58119    }
    59     printFooter(stdout, "psVectorSort", "Sort float vector", true);
    60 
    61 
    62     // Test C - Sort input float vector into itself
    63     printPositiveTestHeader(stdout,"psVectorSort", "Sort input float vector into itself");
    64     in = psVectorSort(in, in);
    65     for(psS32 i=0; i<7; i++) {
    66         printf("vec[%d] = %f\n", i, out->data.F32[i]);
     120    if(in->data.F32[3] != 5.0f) {
     121        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[3]");
     122        return 400;
     123    }
     124    if(in->data.F32[4] != 5.0f) {
     125        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[4]");
     126        return 500;
     127    }
     128    if(in->data.F32[5] != 7.0f) {
     129        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[5]");
     130        return 600;
     131    }
     132    if(in->data.F32[6] != 9.0f) {
     133        psError(PS_ERR_UNKNOWN,true,"Improper self sort in[6]");
     134        return 700;
    67135    }
    68136    printFooter(stdout, "psVectorSort", "Sort input float vector into itself", true);
     137
     138    // Test C - Attempt to sort vector with invalid type
     139    printPositiveTestHeader(stdout,"psVectorSort","Invalid vector type");
     140    in->type.type = PS_TYPE_BOOL;
     141    out = psVectorAlloc(7,PS_TYPE_F32);
     142    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error messgae");
     143    tempVec = psVectorSort(out,in);
     144    if(tempVec != out) {
     145        psError(PS_ERR_UNKNOWN,true,"Did not return the specified output vector");
     146        return 33;
     147    }
     148    psFree(out);
     149    printFooter(stdout,"psVectorSort","Invalid vector type",true);
     150
     151    // Test D - Sort vector with zero elements
     152    printPositiveTestHeader(stdout,"psVectorSort","Sort zero element vector");
     153    out = psVectorAlloc(7,PS_TYPE_F32);
     154    tempVec = out;
     155    in->n = 0;
     156    out = psVectorSort(out,in);
     157    if(tempVec != out) {
     158        psError(PS_ERR_UNKNOWN,true,"Did not return the specified output vector");
     159        return 44;
     160    }
     161    if(out->n != 0) {
     162        psError(PS_ERR_UNKNOWN,true,"Did not proper set the number of elements to zero");
     163        return 55;
     164    }
     165    printFooter(stdout,"psVectorSort","Sort zero element vector",true);
    69166
    70167

  • trunk/psLib/test/collections/verified/tst_psVectorSort_01.stderr

    r1299 r2669  
     1<DATE><TIME>|<HOST>|I|main
     2    Following should generate an error messgae
     3<DATE><TIME>|<HOST>|E|psVectorSort (psVector.c:<LINENO>)
     4    Input psVector is an unsupported type (4865).

  • trunk/psLib/test/collections/verified/tst_psVectorSort_01.stdout

    r1299 r2669  
    11/***************************** TESTPOINT ******************************************\
    22*             TestFile: tst_psVectorSort_01.c                                      *
    3 *            TestPoint: psVectorSort{Create float vectors}                         *
     3*            TestPoint: psVectorSort{Sort all types}                               *
    44*             TestType: Positive                                                   *
    55\**********************************************************************************/
    66
    7 vec[0] = 7.000000
    8 vec[1] = 9.000000
    9 vec[2] = 3.000000
    10 vec[3] = 1.000000
    11 vec[4] = 5.000000
    12 vec[5] = 5.000000
    13 vec[6] = -20.000000
    147
    15 ---> TESTPOINT PASSED (psVectorSort{Create float vectors} | tst_psVectorSort_01.c)
    16 
    17 /***************************** TESTPOINT ******************************************\
    18 *             TestFile: tst_psVectorSort_01.c                                      *
    19 *            TestPoint: psVectorSort{Sort float vector}                            *
    20 *             TestType: Positive                                                   *
    21 \**********************************************************************************/
    22 
    23 vec[0] = -20.000000
    24 vec[1] = 1.000000
    25 vec[2] = 3.000000
    26 vec[3] = 5.000000
    27 vec[4] = 5.000000
    28 vec[5] = 7.000000
    29 vec[6] = 9.000000
    30 
    31 ---> TESTPOINT PASSED (psVectorSort{Sort float vector} | tst_psVectorSort_01.c)
     8---> TESTPOINT PASSED (psVectorSort{Sort all types} | tst_psVectorSort_01.c)
    329
    3310/***************************** TESTPOINT ******************************************\
    … …  
    3714\**********************************************************************************/
    3815
    39 vec[0] = -20.000000
    40 vec[1] = 1.000000
    41 vec[2] = 3.000000
    42 vec[3] = 5.000000
    43 vec[4] = 5.000000
    44 vec[5] = 7.000000
    45 vec[6] = 9.000000
    4616
    4717---> TESTPOINT PASSED (psVectorSort{Sort input float vector into itself} | tst_psVectorSort_01.c)
     18
     19/***************************** TESTPOINT ******************************************\
     20*             TestFile: tst_psVectorSort_01.c                                      *
     21*            TestPoint: psVectorSort{Invalid vector type}                          *
     22*             TestType: Positive                                                   *
     23\**********************************************************************************/
     24
     25
     26---> TESTPOINT PASSED (psVectorSort{Invalid vector type} | tst_psVectorSort_01.c)
     27
     28/***************************** TESTPOINT ******************************************\
     29*             TestFile: tst_psVectorSort_01.c                                      *
     30*            TestPoint: psVectorSort{Sort zero element vector}                     *
     31*             TestType: Positive                                                   *
     32\**********************************************************************************/
     33
     34
     35---> TESTPOINT PASSED (psVectorSort{Sort zero element vector} | tst_psVectorSort_01.c)
    4836
    4937/***************************** TESTPOINT ******************************************\
Note: See TracChangeset for help on using the changeset viewer.