IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 18, 2005, 12:17:20 PM (21 years ago)
Author:
desonia
Message:

* empty log message *

Location:
trunk/psLib/test/collections
Files:
1 deleted
2 edited

Legend:

Unmodified
Added
Removed

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

    r3281 r3286  
    1717 *  @author  Ross Harman, MHPCC
    1818 *
    19  *  @version $Revision: 1.11 $  $Name: not supported by cvs2svn $
    20  *  @date  $Date: 2005-02-18 00:01:39 $
     19 *  @version $Revision: 1.12 $  $Name: not supported by cvs2svn $
     20 *  @date  $Date: 2005-02-18 22:17:20 $
    2121 *
    2222 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7575
    7676    // Test A - Create void pointer array
    77     printPositiveTestHeader(stdout,"psArray", "Create void pointer array");
     77    printPositiveTestHeader(stderr,"psArray", "Create void pointer array");
    7878    psArray *psArr = psArrayAlloc(5);
    7979    if (psArr->nalloc != 5) {
    … …  
    8181        return 1;
    8282    }
    83     printFooter(stdout, "psArray", "Create void pointer array", true);
     83    printFooter(stderr, "psArray", "Create void pointer array", true);
    8484
    8585
    8686    // Test B - Add data to void pointer array
    87     printPositiveTestHeader(stdout, "psArray", "Add data to void pointer array");
     87    printPositiveTestHeader(stderr, "psArray", "Add data to void pointer array");
    8888    for(psS32 i = 0; i < 5; i++) {
    8989        testStruct *ts = psAlloc(sizeof(testStruct));
    … …  
    9797    for(psS32 i = 0; i < 5; i++) {
    9898        testStruct *ts = (testStruct*)psArr->data[i];
    99         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     99        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    100100        if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
    101101            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    103103        }
    104104    }
    105     printf("array size = %d\n", psArr->nalloc);
     105    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    106106    if (psArr->nalloc != 5) {
    107107        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    108108        return 3;
    109109    }
    110     printf("array population = %d\n", psArr->n);
     110    fprintf(stderr,"array population = %d\n", psArr->n);
    111111    if (psArr->n != 5) {
    112112        psError(PS_ERR_UNKNOWN, true,"Array population wrong");
    113113        return 4;
    114114    }
    115     printFooter(stdout, "psArray", "Add data to void pointer array", true);
     115    printFooter(stderr, "psArray", "Add data to void pointer array", true);
    116116
    117117
    118118    // Test C - Reallocate void pointer array bigger
    119     printPositiveTestHeader(stdout,"psArray", "Reallocate void pointer array bigger");
     119    printPositiveTestHeader(stderr,"psArray", "Reallocate void pointer array bigger");
    120120    psArr = psArrayRealloc(psArr,10);
    121     printf("Adding more elements to void pointer array...\n");
     121    fprintf(stderr,"Adding more elements to void pointer array...\n");
    122122    for(psS32 i = 5; i < 10; i++) {
    123123        testStruct *ts = psAlloc(sizeof(testStruct));
    … …  
    131131    for(psS32 i = 0; i < 10; i++) {
    132132        testStruct *ts = (testStruct*)psArr->data[i];
    133         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     133        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    134134        if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
    135135            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    137137        }
    138138    }
    139     printf("array size = %d\n", psArr->nalloc);
     139    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    140140    if (psArr->nalloc != 10) {
    141141        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    142142        return 6;
    143143    }
    144     printf("array population = %d\n", psArr->n);
     144    fprintf(stderr,"array population = %d\n", psArr->n);
    145145    if (psArr->n != 10) {
    146146        psError(PS_ERR_UNKNOWN, true,"Array Population wrong");
    147147        return 7;
    148148    }
    149     printFooter(stdout, "psArray", "Reallocate void pointer array bigger", true);
     149    printFooter(stderr, "psArray", "Reallocate void pointer array bigger", true);
    150150
    151151    // Test D - Reallocate void pointer array smaller
    152     printPositiveTestHeader(stdout,"psArray","Reallocate void pointer array smaller");
     152    printPositiveTestHeader(stderr,"psArray","Reallocate void pointer array smaller");
    153153    psArr = psArrayRealloc(psArr,3);
    154154    for(psS32 i = 0; i < 3; i++) {
    155155        testStruct *ts = (testStruct*)psArr->data[i];
    156         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     156        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    157157        if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
    158158            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    160160        }
    161161    }
    162     printf("array size = %d\n", psArr->nalloc);
     162    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    163163    if (psArr->nalloc != 3) {
    164164        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    165165        return 9;
    166166    }
    167     printf("array population = %d\n", psArr->n);
     167    fprintf(stderr,"array population = %d\n", psArr->n);
    168168    if (psArr->n != 3) {
    169169        psError(PS_ERR_UNKNOWN, true,"Array Population wrong");
    170170        return 10;
    171171    }
    172     printFooter(stdout, "psArray", "Reallocate integer void pointer smaller", true);
     172    printFooter(stderr, "psArray", "Reallocate integer void pointer smaller", true);
    173173
    174174    // Test E - Reallocate with a null
    175     printNegativeTestHeader(stdout,"psArray","Reallocate with a null array",
     175    printNegativeTestHeader(stderr,"psArray","Reallocate with a null array",
    176176                            "Error message generator", 0 );
    177177    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
    178178    psArr1 = psArrayRealloc(NULL,5);
    179179    if ( psArr1 != NULL ) {
    180         printf("ERROR: Return is not NULL\n");
    181     }
    182     printFooter(stdout,"psArray","Reallocate with a null array",true);
     180        fprintf(stderr,"ERROR: Return is not NULL\n");
     181    }
     182    printFooter(stderr,"psArray","Reallocate with a null array",true);
    183183
    184184
    185185    // Test F - Remove item from array
    186     printPositiveTestHeader(stdout, "psArray", "Remove valid item");
     186    printPositiveTestHeader(stderr, "psArray", "Remove valid item");
    187187    if( !psArrayRemove(psArr,mySt[0]) ) {
    188188        psError(PS_ERR_UNKNOWN,true,"Unable to remove valid item");
    189189        return 100;
    190190    }
    191     printf("Array size after removal = %d\n",psArr->n);
     191    fprintf(stderr,"Array size after removal = %d\n",psArr->n);
    192192    if ( psArr->n != 2 ) {
    193193        psError(PS_ERR_UNKNOWN, true, "Items in array not decremented after removal");
    … …  
    196196    for(psS32 i = 0; i < psArr->n; i++) {
    197197        testStruct *ts = (testStruct*)psArr->data[i];
    198         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     198        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    199199        if(fabsf(ts->x - 10*(i+1)) > 0.01f || fabsf(ts->y - 10.1*(i+1)) > 0.01f) {
    200200            psError(PS_ERR_UNKNOWN, true, "Elements not as expected after remove.");
    … …  
    203203    }
    204204    psFree(mySt[0]);
    205     printFooter(stdout,"psArray","Remove valid item", true);
     205    printFooter(stderr,"psArray","Remove valid item", true);
    206206
    207207    // Test G - Remove invalid item from array
    208     printPositiveTestHeader(stdout, "psArray", "Remove invalid item from array");
     208    printPositiveTestHeader(stderr, "psArray", "Remove invalid item from array");
    209209    if( psArrayRemove(psArr,mySt[9]) ) {
    210210        psError(PS_ERR_UNKNOWN,true,"Removed invalid item from array");
    211211        return 103;
    212212    }
    213     printFooter(stdout,"psArray","Remove invalid item from array",true);
     213    printFooter(stderr,"psArray","Remove invalid item from array",true);
    214214
    215215    // Test H - Remove item from null array
    216     printPositiveTestHeader(stdout, "psArray", "Remove item from null array");
     216    printPositiveTestHeader(stderr, "psArray", "Remove item from null array");
    217217    if ( psArrayRemove(NULL,mySt[1]) ) {
    218218        psError(PS_ERR_UNKNOWN,true,"Removed valid item from null array");
    219219        return 104;
    220220    }
    221     printFooter(stdout,"psArray","Remove item from null array",true);
     221    printFooter(stderr,"psArray","Remove item from null array",true);
    222222
    223223    // Test I - Remove null item from array
    224     printPositiveTestHeader(stdout, "psArray", "Remove null item from array");
     224    printPositiveTestHeader(stderr, "psArray", "Remove null item from array");
    225225    if( psArrayRemove(psArr,NULL) ) {
    226226        psError(PS_ERR_UNKNOWN,true,"Remove null item from array",true);
    227227        return 105;
    228228    }
    229     printFooter(stdout,"psArray","Remove null item from array",true);
     229    printFooter(stderr,"psArray","Remove null item from array",true);
    230230
    231231    // Test J - Free void pointer array
    232     printPositiveTestHeader(stdout, "psArray", "Free void pointer array");
     232    printPositiveTestHeader(stderr, "psArray", "Free void pointer array");
    233233    psFree(psArr);
    234234    for(psS32 i = 0; i < 10; i++) {
    235235        psFree(mySt[i]);
    236236    }
    237     if( psMemCheckLeaks(0, NULL, stdout, false) != 0) {
     237    if( psMemCheckLeaks(0, NULL, stderr, false) != 0) {
    238238        psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
    239239        return 110;
    … …  
    241241    psS32 nBad = psMemCheckCorruption(0);
    242242    if(nBad) {
    243         printf("ERROR: Found %d bad memory blocks\n", nBad);
     243        fprintf(stderr,"ERROR: Found %d bad memory blocks\n", nBad);
    244244        return 111;
    245245    }
    246     printFooter(stdout, "psArray" ,"Free void pointer array", true);
     246    printFooter(stderr, "psArray" ,"Free void pointer array", true);
    247247
    248248    return 0;
    … …  
    255255
    256256    // Test A - Create void pointer array
    257     printPositiveTestHeader(stdout,"psArray", "Create void pointer array");
     257    printPositiveTestHeader(stderr,"psArray", "Create void pointer array");
    258258    psArray *psArr = psArrayAlloc(10);
    259259    if (psArr->nalloc != 10) {
    … …  
    261261        return 1;
    262262    }
    263     printFooter(stdout, "psArray", "Create void pointer array", true);
     263    printFooter(stderr, "psArray", "Create void pointer array", true);
    264264
    265265    // Test B - Add data to void pointer array
    266     printPositiveTestHeader(stdout, "psArray", "Add data to void pointer array");
     266    printPositiveTestHeader(stderr, "psArray", "Add data to void pointer array");
    267267    for(psS32 i = 0; i < 10; i++) {
    268268        testStruct *ts = psAlloc(sizeof(testStruct));
    … …  
    276276    for(psS32 i = 0; i < 10; i++) {
    277277        testStruct *ts = (testStruct*)psArr->data[i];
    278         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     278        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    279279        if (fabsf(ts->x - 10*(10-i)) > 0.01f || fabsf(ts->y - 10.1*(10-i)) > 0.01f) {
    280280            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    282282        }
    283283    }
    284     printf("array size = %d\n", psArr->nalloc);
     284    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    285285    if (psArr->nalloc != 10) {
    286286        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    287287        return 3;
    288288    }
    289     printf("array population = %d\n", psArr->n);
     289    fprintf(stderr,"array population = %d\n", psArr->n);
    290290    if (psArr->n != 10) {
    291291        psError(PS_ERR_UNKNOWN, true,"Array population wrong");
    292292        return 4;
    293293    }
    294     printFooter(stdout, "psArray", "Add data to void pointer array", true);
     294    printFooter(stderr, "psArray", "Add data to void pointer array", true);
    295295
    296296    // Test C - Sort data in array
    297     printPositiveTestHeader(stdout,"psArray","Sort data in array");
     297    printPositiveTestHeader(stderr,"psArray","Sort data in array");
    298298    psArr = psArraySort(psArr,testStructCompare);
    299299    for(psS32 i = 0; i < 10; i++) {
    300300        testStruct *ts = (testStruct*)psArr->data[i];
    301         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     301        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    302302        if (fabsf(ts->x - 10*(i+1)) > 0.01f || fabsf(ts->y - 10.1*(i+1)) > 0.01f) {
    303303            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    305305        }
    306306    }
    307     printFooter(stdout,"psArray","Sort data in array",true);
     307    printFooter(stderr,"psArray","Sort data in array",true);
    308308
    309309    // Test D - Attempt to sort null array
    310     printPositiveTestHeader(stdout,"psArray","Attempt to sort array");
     310    printPositiveTestHeader(stderr,"psArray","Attempt to sort array");
    311311    psArray* tempArr = psArraySort(NULL,testStructCompare);
    312312    if(tempArr != NULL) {
    … …  
    314314        return 6;
    315315    }
    316     printFooter(stdout,"psArray","Attempt to sort array",true);
     316    printFooter(stderr,"psArray","Attempt to sort array",true);
    317317
    318318    // Test E - Free void pointer array
    319     printPositiveTestHeader(stdout, "psArray", "Free void pointer array");
     319    printPositiveTestHeader(stderr, "psArray", "Free void pointer array");
    320320    psFree(psArr);
    321321    for(psS32 i = 0; i < 10; i++) {
    322322        psFree(mySt[i]);
    323323    }
    324     if( psMemCheckLeaks(0, NULL, stdout, false) != 0) {
     324    if( psMemCheckLeaks(0, NULL, stderr, false) != 0) {
    325325        psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
    326326        return 110;
    … …  
    328328    psS32 nBad = psMemCheckCorruption(0);
    329329    if(nBad) {
    330         printf("ERROR: Found %d bad memory blocks\n", nBad);
     330        fprintf(stderr,"ERROR: Found %d bad memory blocks\n", nBad);
    331331        return 111;
    332332    }
    333     printFooter(stdout, "psArray" ,"Free void pointer array", true);
     333    printFooter(stderr, "psArray" ,"Free void pointer array", true);
    334334
    335335    return 0;
    … …  
    352352        data = psAlloc(sizeof(float));
    353353        arr = psArrayAdd(arr, delta*2, data); // make delta unique versus next delta used.
     354
     355        subtest++;
     356        if (psMemGetRefCounter(data) != 2) {
     357            // in response of Bug #302
     358            psError(PS_ERR_UNKNOWN, true,
     359                    "psArrayAdd did not increment the data reference count.");
     360            return subtest;
     361        }
     362
     363        psFree(data);
    354364
    355365        subtest++;
    … …  
    381391    data = psAlloc(sizeof(float));
    382392    arr = psArrayAdd(arr, delta, data);
     393    psFree(data);
    383394
    384395    // make sure the array was expanded
    … …  
    411422        data = psAlloc(sizeof(float));
    412423        arr = psArrayAdd(arr, 0, data);
     424        psFree(data);
    413425    }
    414426    nalloc = arr->nalloc;
    … …  
    419431    data = psAlloc(sizeof(float));
    420432    arr = psArrayAdd(arr, 0, data);
     433    psFree(data);
    421434
    422435    subtest++;

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

    r3127 r3286  
    1 <DATE><TIME>|<HOST>|I|main
     1/***************************** TESTPOINT ******************************************\
     2*             TestFile: tst_psArray.c                                              *
     3*            TestPoint: psArray{psArray}                                           *
     4*             TestType: Positive                                                   *
     5\**********************************************************************************/
     6
     7/***************************** TESTPOINT ******************************************\
     8*             TestFile: tst_psArray.c                                              *
     9*            TestPoint: psArray{Create void pointer array}                         *
     10*             TestType: Positive                                                   *
     11\**********************************************************************************/
     12
     13
     14---> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
     15
     16/***************************** TESTPOINT ******************************************\
     17*             TestFile: tst_psArray.c                                              *
     18*            TestPoint: psArray{Add data to void pointer array}                    *
     19*             TestType: Positive                                                   *
     20\**********************************************************************************/
     21
     22ts[0].x = 0 ts[0].y = 0.00
     23ts[1].x = 10 ts[1].y = 10.10
     24ts[2].x = 20 ts[2].y = 20.20
     25ts[3].x = 30 ts[3].y = 30.30
     26ts[4].x = 40 ts[4].y = 40.40
     27array size = 5
     28array population = 5
     29
     30---> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
     31
     32/***************************** TESTPOINT ******************************************\
     33*             TestFile: tst_psArray.c                                              *
     34*            TestPoint: psArray{Reallocate void pointer array bigger}              *
     35*             TestType: Positive                                                   *
     36\**********************************************************************************/
     37
     38Adding more elements to void pointer array...
     39ts[0].x = 0 ts[0].y = 0.00
     40ts[1].x = 10 ts[1].y = 10.10
     41ts[2].x = 20 ts[2].y = 20.20
     42ts[3].x = 30 ts[3].y = 30.30
     43ts[4].x = 40 ts[4].y = 40.40
     44ts[5].x = 50 ts[5].y = 50.50
     45ts[6].x = 60 ts[6].y = 60.60
     46ts[7].x = 70 ts[7].y = 70.70
     47ts[8].x = 80 ts[8].y = 80.80
     48ts[9].x = 90 ts[9].y = 90.90
     49array size = 10
     50array population = 10
     51
     52---> TESTPOINT PASSED (psArray{Reallocate void pointer array bigger} | tst_psArray.c)
     53
     54/***************************** TESTPOINT ******************************************\
     55*             TestFile: tst_psArray.c                                              *
     56*            TestPoint: psArray{Reallocate void pointer array smaller}             *
     57*             TestType: Positive                                                   *
     58\**********************************************************************************/
     59
     60ts[0].x = 0 ts[0].y = 0.00
     61ts[1].x = 10 ts[1].y = 10.10
     62ts[2].x = 20 ts[2].y = 20.20
     63array size = 3
     64array population = 3
     65
     66---> TESTPOINT PASSED (psArray{Reallocate integer void pointer smaller} | tst_psArray.c)
     67
     68/***************************** TESTPOINT ******************************************\
     69*             TestFile: tst_psArray.c                                              *
     70*            TestPoint: psArray{Reallocate with a null array}                      *
     71*             TestType: Negative                                                   *
     72*    ExpectedErrorText: Error message generator                                    *
     73*  ExpectedStatusValue: 0                                                          *
     74\**********************************************************************************/
     75
     76<DATE><TIME>|<HOST>|I|testArray
    277    Following should generate an error message.
    378<DATE><TIME>|<HOST>|E|psArrayRealloc (FILE:LINENO)
    479    psArrayRealloc must be given a non-NULL psArray to resize.
     80
     81---> TESTPOINT PASSED (psArray{Reallocate with a null array} | tst_psArray.c)
     82
     83/***************************** TESTPOINT ******************************************\
     84*             TestFile: tst_psArray.c                                              *
     85*            TestPoint: psArray{Remove valid item}                                 *
     86*             TestType: Positive                                                   *
     87\**********************************************************************************/
     88
     89Array size after removal = 2
     90ts[0].x = 10 ts[0].y = 10.10
     91ts[1].x = 20 ts[1].y = 20.20
     92
     93---> TESTPOINT PASSED (psArray{Remove valid item} | tst_psArray.c)
     94
     95/***************************** TESTPOINT ******************************************\
     96*             TestFile: tst_psArray.c                                              *
     97*            TestPoint: psArray{Remove invalid item from array}                    *
     98*             TestType: Positive                                                   *
     99\**********************************************************************************/
     100
     101
     102---> TESTPOINT PASSED (psArray{Remove invalid item from array} | tst_psArray.c)
     103
     104/***************************** TESTPOINT ******************************************\
     105*             TestFile: tst_psArray.c                                              *
     106*            TestPoint: psArray{Remove item from null array}                       *
     107*             TestType: Positive                                                   *
     108\**********************************************************************************/
     109
    5110<DATE><TIME>|<HOST>|E|psArrayRemove (FILE:LINENO)
    6111    Specified psArray can not be NULL.
     112
     113---> TESTPOINT PASSED (psArray{Remove item from null array} | tst_psArray.c)
     114
     115/***************************** TESTPOINT ******************************************\
     116*             TestFile: tst_psArray.c                                              *
     117*            TestPoint: psArray{Remove null item from array}                       *
     118*             TestType: Positive                                                   *
     119\**********************************************************************************/
     120
     121
     122---> TESTPOINT PASSED (psArray{Remove null item from array} | tst_psArray.c)
     123
     124/***************************** TESTPOINT ******************************************\
     125*             TestFile: tst_psArray.c                                              *
     126*            TestPoint: psArray{Free void pointer array}                           *
     127*             TestType: Positive                                                   *
     128\**********************************************************************************/
     129
     130
     131---> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
     132
     133
     134---> TESTPOINT PASSED (psArray{psArray} | tst_psArray.c)
     135
     136/***************************** TESTPOINT ******************************************\
     137*             TestFile: tst_psArray.c                                              *
     138*            TestPoint: psArray{psArray}                                           *
     139*             TestType: Positive                                                   *
     140\**********************************************************************************/
     141
     142/***************************** TESTPOINT ******************************************\
     143*             TestFile: tst_psArray.c                                              *
     144*            TestPoint: psArray{Create void pointer array}                         *
     145*             TestType: Positive                                                   *
     146\**********************************************************************************/
     147
     148
     149---> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
     150
     151/***************************** TESTPOINT ******************************************\
     152*             TestFile: tst_psArray.c                                              *
     153*            TestPoint: psArray{Add data to void pointer array}                    *
     154*             TestType: Positive                                                   *
     155\**********************************************************************************/
     156
     157ts[0].x = 100 ts[0].y = 101.00
     158ts[1].x = 90 ts[1].y = 90.90
     159ts[2].x = 80 ts[2].y = 80.80
     160ts[3].x = 70 ts[3].y = 70.70
     161ts[4].x = 60 ts[4].y = 60.60
     162ts[5].x = 50 ts[5].y = 50.50
     163ts[6].x = 40 ts[6].y = 40.40
     164ts[7].x = 30 ts[7].y = 30.30
     165ts[8].x = 20 ts[8].y = 20.20
     166ts[9].x = 10 ts[9].y = 10.10
     167array size = 10
     168array population = 10
     169
     170---> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
     171
     172/***************************** TESTPOINT ******************************************\
     173*             TestFile: tst_psArray.c                                              *
     174*            TestPoint: psArray{Sort data in array}                                *
     175*             TestType: Positive                                                   *
     176\**********************************************************************************/
     177
     178ts[0].x = 10 ts[0].y = 10.10
     179ts[1].x = 20 ts[1].y = 20.20
     180ts[2].x = 30 ts[2].y = 30.30
     181ts[3].x = 40 ts[3].y = 40.40
     182ts[4].x = 50 ts[4].y = 50.50
     183ts[5].x = 60 ts[5].y = 60.60
     184ts[6].x = 70 ts[6].y = 70.70
     185ts[7].x = 80 ts[7].y = 80.80
     186ts[8].x = 90 ts[8].y = 90.90
     187ts[9].x = 100 ts[9].y = 101.00
     188
     189---> TESTPOINT PASSED (psArray{Sort data in array} | tst_psArray.c)
     190
     191/***************************** TESTPOINT ******************************************\
     192*             TestFile: tst_psArray.c                                              *
     193*            TestPoint: psArray{Attempt to sort array}                             *
     194*             TestType: Positive                                                   *
     195\**********************************************************************************/
     196
     197
     198---> TESTPOINT PASSED (psArray{Attempt to sort array} | tst_psArray.c)
     199
     200/***************************** TESTPOINT ******************************************\
     201*             TestFile: tst_psArray.c                                              *
     202*            TestPoint: psArray{Free void pointer array}                           *
     203*             TestType: Positive                                                   *
     204\**********************************************************************************/
     205
     206
     207---> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
     208
     209
     210---> TESTPOINT PASSED (psArray{psArray} | tst_psArray.c)
     211
     212/***************************** TESTPOINT ******************************************\
     213*             TestFile: tst_psArray.c                                              *
     214*            TestPoint: psArray{psArrayAdd}                                        *
     215*             TestType: Positive                                                   *
     216\**********************************************************************************/
     217
     218
     219---> TESTPOINT PASSED (psArray{psArrayAdd} | tst_psArray.c)
     220
Note: See TracChangeset for help on using the changeset viewer.