IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 4, 2007, 10:25:32 AM (19 years ago)
Author:
gusciora
Message:

Improved test coverage.

Location:
trunk/psLib/test/imageops
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/imageops/tap_psImageGeomManip.c

    r13123 r13614  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2007-05-02 04:14:33 $
     7 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2007-06-04 20:25:32 $
    99 *
    1010 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1616#include "pstap.h"
    1717#define VERBOSE 0
     18
     19void genericImageRollTest(int numRows, int numCols)
     20{
     21    psMemId id = psMemGetId();
     22    psImage *in;
     23    psImage *out;
     24    psImage *out2;
     25
     26    // The function psImageRoll shall generate a new psImage structure by
     27    // rolling the input image the correponding number of pixels in the vertical
     28    // and/or horizontal direction. The image output image shall be the same size
     29    // as the input image. Values which roll off the image are wrapped to the
     30    // other side.
     31    //
     32    // Verify the returned psImage structure contains expected values, if the
     33    // input image contains known values and the roll performed is known.
     34    // Cases should include no roll, vertical roll, horizontal roll and
     35    // combination vertical/horizontal rolls. Positive and negative rolls
     36    // should be performed.
     37
     38    in = psImageAlloc(numCols,numRows,PS_TYPE_F32);
     39    for (psS32 row=0;row<numRows;row++) {
     40        for (psS32 col=0;col<numCols;col++) {
     41            in->data.F32[row][col] = (psF32)row+(psF32)col/1000.0f;
     42        }
     43    }
     44
     45    out = psImageRoll(NULL,in,0,0);
     46    bool errorFlag = false;
     47    for (psS32 row=0;row<numRows;row++) {
     48        psF32 *inRow = in->data.F32[row];
     49        psF32 *outRow = out->data.F32[row];
     50        for (psS32 col=0;col<numCols;col++) {
     51            if (inRow[col] != outRow[col]) {
     52                diag("psImageRoll didn't produce expected result "
     53                     "at %d,%d (%f vs %f) for dx=0, dy=0",
     54                     col,row,inRow[col],outRow[col]);
     55                errorFlag = true;
     56            }
     57        }
     58    }
     59    ok(!errorFlag, "psImageRoll() produced the correct data values (no roll)");
     60
     61    errorFlag = false;
     62    out2 = psImageRoll(out,in,numCols/4,0);
     63    for (psS32 row=0;row<numRows;row++)
     64    {
     65        psF32 *inRow = in->data.F32[row];
     66        psF32 *outRow = out->data.F32[row];
     67        for (psS32 col=0;col<numCols;col++) {
     68            if (inRow[(col+numCols/4) % numCols] != outRow[col]) {
     69                diag("psImageRoll didn't produce expected result "
     70                     "at %d,%d (%f vs %f) for dx=numCols/4, dy=0",
     71                     col,row,inRow[(col+numCols/4) % numCols],outRow[col]);
     72                errorFlag = true;
     73            }
     74        }
     75    }
     76    ok(!errorFlag, "psImageRoll() produced the correct data values (column roll only");
     77
     78    // Verify the returned psImage structure pointer is equal to the input
     79    // parameter out if provided.
     80    ok(out2 == out, "psImageRoll did recycle the out psImage");
     81
     82    errorFlag = false;
     83    out = psImageRoll(out,in,0,numRows/4);
     84    for (psS32 row=0;row<numRows;row++)
     85    {
     86        psF32 *inRow = in->data.F32[(row+numRows/4)%numRows];
     87        psF32 *outRow = out->data.F32[row];
     88        for (psS32 col=0;col<numCols;col++) {
     89            if (inRow[col] != outRow[col]) {
     90                diag("psImageRoll didn't produce expected result "
     91                     "at %d,%d (%f vs %f) for dx=0, dy=numRows/4",
     92                     col,row,inRow[col],outRow[col]);
     93                errorFlag = true;
     94            }
     95        }
     96    }
     97    ok(!errorFlag, "psImageRoll() produced the correct data values (row roll onlt)");
     98
     99    errorFlag = false;
     100    out = psImageRoll(out,in,numCols/4,numRows/4);
     101    for (psS32 row=0;row<numRows;row++)
     102    {
     103        psF32 *inRow = in->data.F32[(row+numRows/4)%numRows];
     104        psF32 *outRow = out->data.F32[row];
     105        for (psS32 col=0;col<numCols;col++) {
     106            if (inRow[(col+numCols/4) % numCols] != outRow[col]) {
     107                diag("psImageRoll didn't produce expected result "
     108                     "at %d,%d (%f vs %f) for dx=numCols/4, dy=numRows/4",
     109                     col,row,inRow[(col+numCols/4) % numCols],outRow[col]);
     110                errorFlag = true;
     111            }
     112        }
     113    }
     114    ok(!errorFlag, "psImageRoll() produced the correct data values (column and row roll)");
     115
     116    errorFlag = false;
     117    out = psImageRoll(out,in,-numCols/4,0);
     118    for (psS32 row=0;row<numRows;row++)
     119    {
     120        psF32 *inRow = in->data.F32[row];
     121        psF32 *outRow = out->data.F32[row];
     122        for (psS32 col=0;col<numCols;col++) {
     123            if (inRow[(col+(numCols-numCols/4)) % numCols] != outRow[col]) {
     124                diag("psImageRoll didn't produce expected result "
     125                     "at %d,%d (%f vs %f) for dx=-numCols/4, dy=0",
     126                     col,row,inRow[(col+(numCols-numCols/4)) % numCols],outRow[col]);
     127                errorFlag = true;
     128            }
     129        }
     130    }
     131    ok(!errorFlag, "psImageRoll() produced the correct data values (negative column roll)");
     132
     133    errorFlag = false;
     134    out = psImageRoll(out,in,0,-numRows/4);
     135    for (psS32 row=0;row<numRows;row++)
     136    {
     137        psF32 *inRow = in->data.F32[(row+numRows-numRows/4)%numRows];
     138        psF32 *outRow = out->data.F32[row];
     139        for (psS32 col=0;col<numCols;col++) {
     140            if (inRow[col] != outRow[col]) {
     141                diag("psImageRoll didn't produce expected result "
     142                     "at %d,%d (%f vs %f) for dx=0, dy=-numRows/4",
     143                     col,row,inRow[col],outRow[col]);
     144                errorFlag = true;
     145            }
     146        }
     147    }
     148    ok(!errorFlag, "psImageRoll() produced the correct data values (negative row roll)");
     149
     150    errorFlag = false;
     151    out = psImageRoll(out,in,-numCols/4,-numRows/4);
     152    for (psS32 row=0;row<numRows;row++)
     153    {
     154        psF32 *inRow = in->data.F32[(row+numRows-numRows/4)%numRows];
     155        psF32 *outRow = out->data.F32[row];
     156        for (psS32 col=0;col<numCols;col++) {
     157            if (inRow[(col+numCols-numCols/4) % numCols] != outRow[col]) {
     158                diag("psImageRoll didn't produce expected result "
     159                     "at %d,%d (%f vs %f) for dx=numCols/4, dy=numRows/4",
     160                     col,row,inRow[(col+numCols-numCols/4) % numCols],outRow[col]);
     161                errorFlag = true;
     162            }
     163        }
     164    }
     165    ok(!errorFlag, "psImageRoll() produced the correct data values (negative column and row roll)");
     166    psFree(in);
     167    psFree(out);
     168    ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     169}
     170
     171
    18172
    19173bool testImageShiftCase(psS32 cols,
    … …  
    152306    psLogSetFormat("HLNM");
    153307    psLogSetLevel(PS_LOG_INFO);
    154     plan_tests(237);
     308    plan_tests(280);
    155309
    156310    // test psImageRebin()
    … …  
    366520    if (1) {
    367521        psMemId id = psMemGetId();
     522        // Perform generic tests with various image sizes
     523        genericImageRollTest(8, 1);
     524        genericImageRollTest(1, 8);
     525        genericImageRollTest(8, 8);
     526        genericImageRollTest(8, 16);
     527        genericImageRollTest(16, 8);
     528
    368529        psImage *in;
    369530        psImage *out;
    … …  
    373534        psS32 rows1 = 8;
    374535        psS32 cols1 = 8;
    375 
    376         // The function psImageRoll shall generate a new psImage structure by
    377         // rolling the input image the correponding number of pixels in the vertical
    378         // and/or horizontal direction. The image output image shall be the same size
    379         // as the input image. Values which roll off the image are wrapped to the
    380         // other side.
    381         //
    382         // Verify the returned psImage structure contains expected values, if the
    383         // input image contains known values and the roll performed is known.
    384         // Cases should include no roll, vertical roll, horizontal roll and
    385         // combination vertical/horizontal rolls. Positive and negative rolls
    386         // should be performed.
    387 
    388536        in = psImageAlloc(cols,rows,PS_TYPE_F32);
    389537        for (psS32 row=0;row<rows;row++) {
    … …  
    393541        }
    394542
    395         out = psImageRoll(NULL,in,0,0);
    396543        bool errorFlag = false;
    397         for (psS32 row=0;row<rows;row++) {
    398             psF32 *inRow = in->data.F32[row];
    399             psF32 *outRow = out->data.F32[row];
    400             for (psS32 col=0;col<cols;col++) {
    401                 if (inRow[col] != outRow[col]) {
    402                     diag("psImageRoll didn't produce expected result "
    403                          "at %d,%d (%f vs %f) for dx=0, dy=0",
    404                          col,row,inRow[col],outRow[col]);
    405                     errorFlag = true;
    406                 }
    407             }
    408         }
    409         ok(!errorFlag, "psImageRoll() produced the correct data values");
    410 
    411         errorFlag = false;
    412         out2 = psImageRoll(out,in,cols/4,0);
    413         for (psS32 row=0;row<rows;row++)
    414         {
    415             psF32 *inRow = in->data.F32[row];
    416             psF32 *outRow = out->data.F32[row];
    417             for (psS32 col=0;col<cols;col++) {
    418                 if (inRow[(col+cols/4) % cols] != outRow[col]) {
    419                     diag("psImageRoll didn't produce expected result "
    420                          "at %d,%d (%f vs %f) for dx=cols/4, dy=0",
    421                          col,row,inRow[(col+cols/4) % cols],outRow[col]);
    422                     errorFlag = true;
    423                 }
    424             }
    425         }
    426         ok(!errorFlag, "psImageRoll() produced the correct data values");
    427 
    428         // Verify the returned psImage structure pointer is equal to the input
    429         // parameter out if provided.
    430         ok(out2 == out, "psImageRoll didt recycle the out psImage");
    431 
    432         errorFlag = false;
    433         out = psImageRoll(out,in,0,rows/4);
    434         for (psS32 row=0;row<rows;row++)
    435         {
    436             psF32 *inRow = in->data.F32[(row+rows/4)%rows];
    437             psF32 *outRow = out->data.F32[row];
    438             for (psS32 col=0;col<cols;col++) {
    439                 if (inRow[col] != outRow[col]) {
    440                     diag("psImageRoll didn't produce expected result "
    441                          "at %d,%d (%f vs %f) for dx=0, dy=rows/4",
    442                          col,row,inRow[col],outRow[col]);
    443                     errorFlag = true;
    444                 }
    445             }
    446         }
    447         ok(!errorFlag, "psImageRoll() produced the correct data values");
    448 
    449         errorFlag = false;
    450         out = psImageRoll(out,in,cols/4,rows/4);
    451         for (psS32 row=0;row<rows;row++)
    452         {
    453             psF32 *inRow = in->data.F32[(row+rows/4)%rows];
    454             psF32 *outRow = out->data.F32[row];
    455             for (psS32 col=0;col<cols;col++) {
    456                 if (inRow[(col+cols/4) % cols] != outRow[col]) {
    457                     diag("psImageRoll didn't produce expected result "
    458                          "at %d,%d (%f vs %f) for dx=cols/4, dy=rows/4",
    459                          col,row,inRow[(col+cols/4) % cols],outRow[col]);
    460                     errorFlag = true;
    461                 }
    462             }
    463         }
    464         ok(!errorFlag, "psImageRoll() produced the correct data values");
    465 
    466         errorFlag = false;
    467         out = psImageRoll(out,in,-cols/4,0);
    468         for (psS32 row=0;row<rows;row++)
    469         {
    470             psF32 *inRow = in->data.F32[row];
    471             psF32 *outRow = out->data.F32[row];
    472             for (psS32 col=0;col<cols;col++) {
    473                 if (inRow[(col+(cols-cols/4)) % cols] != outRow[col]) {
    474                     diag("psImageRoll didn't produce expected result "
    475                          "at %d,%d (%f vs %f) for dx=-cols/4, dy=0",
    476                          col,row,inRow[(col+(cols-cols/4)) % cols],outRow[col]);
    477                     errorFlag = true;
    478                 }
    479             }
    480         }
    481         ok(!errorFlag, "psImageRoll() produced the correct data values");
    482 
    483         errorFlag = false;
    484         out = psImageRoll(out,in,0,-rows/4);
    485         for (psS32 row=0;row<rows;row++)
    486         {
    487             psF32 *inRow = in->data.F32[(row+rows-rows/4)%rows];
    488             psF32 *outRow = out->data.F32[row];
    489             for (psS32 col=0;col<cols;col++) {
    490                 if (inRow[col] != outRow[col]) {
    491                     diag("psImageRoll didn't produce expected result "
    492                          "at %d,%d (%f vs %f) for dx=0, dy=-rows/4",
    493                          col,row,inRow[col],outRow[col]);
    494                     errorFlag = true;
    495                 }
    496             }
    497         }
    498         ok(!errorFlag, "psImageRoll() produced the correct data values");
    499 
    500         errorFlag = false;
    501         out = psImageRoll(out,in,-cols/4,-rows/4);
    502         for (psS32 row=0;row<rows;row++)
    503         {
    504             psF32 *inRow = in->data.F32[(row+rows-rows/4)%rows];
    505             psF32 *outRow = out->data.F32[row];
    506             for (psS32 col=0;col<cols;col++) {
    507                 if (inRow[(col+cols-cols/4) % cols] != outRow[col]) {
    508                     diag("psImageRoll didn't produce expected result "
    509                          "at %d,%d (%f vs %f) for dx=cols/4, dy=rows/4",
    510                          col,row,inRow[(col+cols-cols/4) % cols],outRow[col]);
    511                     errorFlag = true;
    512                 }
    513             }
    514         }
    515         ok(!errorFlag, "psImageRoll() produced the correct data values");
    516 
    517 
    518544        // Verify the returned psImage structure pointer is NULL and program
    519545        // execution doesn't stop, if input parameter input is NULL.

  • trunk/psLib/test/imageops/tap_psImagePixelExtract.c

    r13127 r13614  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2007-05-02 04:34:13 $
     8*  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2007-06-04 20:25:32 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1717#include "pstap.h"
    1818
     19void genericImageRowColTests(int numRows, int numCols)
     20{
     21    psMemId id = psMemGetId();
     22    psImage *image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     23    for (int i = 0 ; i < numRows; i++) {
     24        for (int j = 0 ; j < numCols; j++) {
     25            image->data.F32[0][0] = (float) i+j;
     26        }
     27    }           
     28
     29    bool errorFlag = false;
     30    for (int i = 0 ; i < numRows; i++) {
     31        psVector *out = psImageRow(NULL, image, i);
     32        ok(out != NULL, "psImageRow returned non-NULL");
     33        if (out != NULL) {
     34            for (int j = 0 ; j < numCols; j++) {
     35                if (out->data.F32[j] != image->data.F32[i][j]) {
     36                    diag("TEST ERROR: image->data.F32[%d][%d] is %f, should be %f", i, j,
     37                         image->data.F32[i][j], out->data.F32[j]);
     38                    errorFlag = true;
     39                }
     40            }
     41            psFree(out);
     42        } else {
     43            errorFlag = true;
     44        }
     45    }
     46    ok(!errorFlag, "psImageRow() passed tests with correct data inputs");
     47    psFree(image);
     48    ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     49}
     50
     51
     52
    1953psS32 main(psS32 argc, char* argv[])
    2054{
    2155    psLogSetFormat("HLNM");
    2256    psLogSetLevel(PS_LOG_INFO);
    23     plan_tests(248);
     57    plan_tests(295);
    2458
    2559    // test psImageSlice()
    … …  
    807841        ok(out == NULL, "psImageCol() returned NULL");
    808842
    809    
    810         //Test valid cases.
    811         //XXX: We do not verify the data values.
    812         P_PSIMAGE_SET_COL0(image, 10);
    813         P_PSIMAGE_SET_ROW0(image, 5);
    814         *(int*)&(image->numRows) = 3;
    815         *(int*)&(image->numCols) = 3;
     843        // Test on correct input data for several sizes   
     844        genericImageRowColTests(1, 8);
     845        genericImageRowColTests(8, 1);
     846        genericImageRowColTests(8, 8);
     847        genericImageRowColTests(8, 16);
     848        genericImageRowColTests(16, 8);
     849        psFree(image);
     850        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");   
     851    }
     852
     853    // testImageRowColF64()
     854    {
     855        psMemId id = psMemGetId();
     856        psVector *rowcol = NULL;
     857        psVector *empty = NULL;
     858        psImage *image = NULL;
     859   
     860        image = psImageAlloc(3, 3, PS_TYPE_F64);
     861        rowcol = psVectorAlloc(3, PS_TYPE_F64);
     862
    816863        image->data.F64[0][0] = 666.666;
    817864        image->data.F64[1][0] = 66.6;
    … …  
    823870        image->data.F64[1][2] = 666.66;
    824871        image->data.F64[2][2] = 66.66;
    825         num = 7;
    826         out = psImageRow(out, image, num);
    827 
    828 
    829         ok(out != NULL, "psImageRow returned non-NULL");
    830         psFree(out);
    831         out = NULL;
    832         num = 11;
    833         out = psImageCol(NULL, image, num);
    834         ok(out != NULL, "psImageCol returned non-NULL");
    835         psFree(out);
    836         out = NULL;
    837 
    838    
    839         num = -3;
    840         out = psImageRow(out, image, num);
    841         ok(out != NULL, "psImageRow returned non-NULL");
    842         psFree(out);
    843         out = NULL;
    844 
    845 
    846         num = -1;
    847         out = psImageCol(NULL, image, num);
    848         ok(out != NULL, "psImageCol returned non-NULL");
    849         psFree(out);
    850         psFree(image);
    851         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    852     }
    853 
    854    
    855 
    856 
    857 
    858 
    859 
    860 
    861 
    862 
    863 
    864 
    865 
    866 
    867 
    868 
    869     // testImageRowColF64()
    870     {
    871         psMemId id = psMemGetId();
    872         psVector *rowcol = NULL;
    873         psVector *empty = NULL;
    874         psImage *image = NULL;
    875    
    876         image = psImageAlloc(3, 3, PS_TYPE_F64);
    877         rowcol = psVectorAlloc(3, PS_TYPE_F64);
    878 
    879         image->data.F64[0][0] = 666.666;
    880         image->data.F64[1][0] = 66.6;
    881         image->data.F64[2][0] = 6.66;
    882         image->data.F64[0][1] = 6.6;
    883         image->data.F64[1][1] = 6.666;
    884         image->data.F64[2][1] = 66.666;
    885         image->data.F64[0][2] = 666.6;
    886         image->data.F64[1][2] = 666.66;
    887         image->data.F64[2][2] = 66.66;
    888872   
    889873        //Test for error with NULL image

  • trunk/psLib/test/imageops/tap_psImagePixelManip.c

    r13123 r13614  
    66 *  @author Robert DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2007-05-02 04:14:33 $
     8 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2007-06-04 20:25:32 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1818#define VERBOSE false
    1919
     20void genericImageClipTest(int numRows, int numCols) {
     21    psMemId id = psMemGetId();
     22
     23    psImage *image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     24    for (int row = 0 ; row < numRows ; row++) {
     25        for (int col = 0 ; col < numCols ; col++) {
     26            image->data.F32[row][col] = (float) (row + col);
     27        }
     28    }
     29    psF32 min = (psF64)numRows/2.0;
     30    psF32 max = (psF64)numRows;
     31
     32    psS32 retVal = psImageClip(image, min, (double)PS_MIN_F32, max, (double)PS_MAX_F32);
     33    int numClipped = 0;
     34    bool errorFlag = false;
     35    for (int row=0;row<numRows;row++) {
     36        for (int col=0;col<numCols;col++) {
     37            psF32 value = (psF32)(row+col);
     38            if (value < min) {
     39                numClipped++;
     40                value = PS_MIN_F32;
     41            } else if (value > max) {
     42                numClipped++;
     43                value = PS_MAX_F32;
     44            }
     45            if (fabsf(image->data.F32[row][col]-value) > FLT_EPSILON) {
     46                diag("Pixel value is not as expected (%g vs %g) at %u,%u",
     47                     (psF64)image->data.F32[row][col], (psF64)value, col, row);
     48                errorFlag = true;
     49            }
     50        }
     51    }
     52    ok(!errorFlag, "psImageClip() produced the correct data values");
     53    ok(retVal == numClipped, "Got the expected number of clips");
     54    psFree(image);
     55
     56    ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     57}
     58
     59
    2060psS32 main(psS32 argc, char* argv[])
    2161{
    2262    psLogSetFormat("HLNM");
    2363    psLogSetLevel(PS_LOG_INFO);
    24     plan_tests(107);
     64    plan_tests(122);
    2565
    2666    // test psImageClip()
    … …  
    4989        // and program executions doesn't stop, if input parameter min is larger than max.
    5090        // create image
     91
     92        genericImageClipTest(8, 1);
     93        genericImageClipTest(1, 8);
     94        genericImageClipTest(8, 8);
     95        genericImageClipTest(8, 16);
     96        genericImageClipTest(16, 8);
     97
    5198        #define testImageClipByType(datatype) \
    5299        { \

  • trunk/psLib/test/imageops/tap_psImageStructManip.c

    r13123 r13614  
    55*  @author Robert DeSonia, MHPCC
    66*
    7 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    8 *  @date $Date: 2007-05-02 04:14:33 $
     7*  psLib functions tested:
     8*     psImageSubset()
     9*     psImageCopy()
     10*     psImageTrim()
     11*
     12*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2007-06-04 20:25:32 $
    914*
    1015*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1621#include "pstap.h"
    1722
    18 psS32 main( psS32 argc, char* argv[] )
     23
     24void genericImageSubsetTest(int numRows, int numCols)
    1925{
    20     psLogSetFormat("HLNM");
    21     psLogSetLevel(PS_LOG_INFO);
    22     plan_tests(185);
    23 
    24 
    2526    // psImageSubset shall create child image of a specified size from a
    2627    // parent psImage structure
    … …  
    2930        psMemId id = psMemGetId();
    3031        psImage preSubsetStruct;
    31         psS32 c = 128;
    32         psS32 r = 256;
    33         psRegion region1 = psRegionSet(0, c/2, 0, r/2);
    34         psRegion region2 = psRegionSet(c/4, c/4+c/2, r/4, r/4+r/2);
    35 
    36         psImage* original = psImageAlloc(c,r,PS_TYPE_U32);
    37         for (psS32 row=0;row<r;row++) {
    38             for (psS32 col=0;col<c;col++) {
     32        psRegion region1 = psRegionSet(0, numCols/2, 0, numRows/2);
     33        psRegion region2 = psRegionSet(numCols/4, numCols/4+numCols/2, numRows/4, numRows/4+numRows/2);
     34
     35        psImage* original = psImageAlloc(numCols,numRows,PS_TYPE_U32);
     36        for (psS32 row=0;row<numRows;row++) {
     37            for (psS32 col=0;col<numCols;col++) {
    3938                original->data.F32[row][col] = row*1000+col;
    4039            }
    4140        }
    4241
    43         memcpy(&preSubsetStruct,original,sizeof(psImage));
    44         psImage* subset2 = psImageSubset(original,region2);
     42        memcpy(&preSubsetStruct, original, sizeof(psImage));
     43        psImage* subset2 = psImageSubset(original, region2);
    4544        ok(subset2, "psImageSubset() returned non-NULL (subset2)");
    4645        skip_start(subset2 == NULL, 25, "Skipping tests because psImageSubset() returned NULL");
    47         psImage* subset3 = psImageSubset(original,region1);
     46        psImage* subset3 = psImageSubset(original, region1);
    4847        ok(subset3, "psImageSubset() returned non-NULL (subset3)");
    4948        skip_start(subset3 == NULL, 24, "Skipping tests because psImageSubset() returned NULL");
    … …  
    5150        // Verify the returned psImage structure members nrow and ncol are equal to
    5251        // the input parameter nrow and ncol respectively
    53         ok(subset2->numCols == c/2 && subset2->numRows == r/2,
     52        ok(subset2->numCols == numCols/2 && subset2->numRows == numRows/2,
    5453           "psImageSubset output size set properly");
    55         ok(subset3->numCols == c/2 && subset3->numRows == r/2,
     54        ok(subset3->numCols == numCols/2 && subset3->numRows == numRows/2,
    5655           "psImageSubset output size set properly");
    5756
    5857        // Verify the returned psImage structure contains expected values in the
    5958        // row member, if the input psImage structure image contains known values
    60 
    6159        bool errorFlag = false;
    62         for (psS32 row=0;row<r/2;row++) {
    63             for (psS32 col=0;col<c/2;col++) {
    64                 if (subset2->data.U32[row][col] != original->data.U32[row+r/4][col+c/4]) {
     60        for (psS32 row=0;row<numRows/2;row++) {
     61            for (psS32 col=0;col<numCols/2;col++) {
     62                if (subset2->data.U32[row][col] != original->data.U32[row+numRows/4][col+numCols/4]) {
    6563                    diag("psImageSubset output #1 was wrong at %dx%d (%d vs %d).",
    66                          row,col,subset2->data.U32[row][col], original->data.U32[row+r/4][col+c/4]);
     64                         row,col,subset2->data.U32[row][col], original->data.U32[row+numRows/4][col+numCols/4]);
    6765                    errorFlag = true;
    6866                }
    … …  
    8381        // Verify the returned psImage structure members row0 and col0 are equal to
    8482        // the input parameters row0 and col0 respectively
    85         ok(subset2->col0 == c/4 && subset2->row0 == r/4,
     83        ok(subset2->col0 == numCols/4 && subset2->row0 == numRows/4,
    8684           "psImageSubset() set col0/row0 correctly (subset2)");
    8785        ok(subset3->col0 == 0 && subset3->row0 == 0,
    … …  
    10199        ok(original->children->data[0] == subset2 && original->children->data[1] == subset3,
    102100           "psImageSubset did properly store the children pointers.");
    103 
    104101
    105102        // Verify the returned psImage structure pointer is null and program
    … …  
    111108        ok(subset1 == NULL, "psImageSubset returned NULL when input image was NULL.");
    112109
    113 
    114110        // Verify the returned psImage structure pointer is null and program
    115111        // execution doesn't stop, if the input parameters nrow and/or ncol are zero.
    … …  
    117113        // An error should follow...
    118114        // XXX: Verify error
    119         memcpy(&preSubsetStruct,original,sizeof(psImage));
    120         subset1 = psImageSubset(original, psRegionSet(0,c/2,r/2,r/2));
    121         ok(subset1 == NULL, "psImageSubset returned NULL when numRows=0.");
    122         // An error should follow...
    123         // XXX: Verify error
    124         subset1 = psImageSubset(original,psRegionSet(c/2,c/2,0,r/2));
    125         ok(subset1 == NULL, "psImageSubset returned NULL when numCols=0.");
    126         ok(memcmp(original,&preSubsetStruct,sizeof(psImage)) == 0,
    127            "psImageSubset didn't change the original struct though it failed to subset.");
     115        {
     116            memcpy(&preSubsetStruct,original,sizeof(psImage));
     117            subset1 = psImageSubset(original, psRegionSet(0,numCols/2,numRows/2,numRows/2));
     118            ok(subset1 == NULL, "psImageSubset returned NULL when numRows=0.");
     119            // An error should follow...
     120            // XXX: Verify error
     121            subset1 = psImageSubset(original,psRegionSet(numCols/2,numCols/2,0,numRows/2));
     122            ok(subset1 == NULL, "psImageSubset returned NULL when numCols=0.");
     123            ok(memcmp(original,&preSubsetStruct,sizeof(psImage)) == 0,
     124               "psImageSubset didn't change the original struct though it failed to subset.");
     125        }
    128126
    129127        // Verify the returned psImage structure pointer is null and program
    … …  
    132130        // An error should follow...
    133131        // XXX: Verify error
    134         subset1 = psImageSubset(original, psRegionSet(0,c/2, 0,r*2));
    135         ok(subset1 == NULL,
    136            "psImageSubset returned NULL when subset origin was outside of image (via cols)");
    137         // An error should follow...
    138         // XXX: Verify error
    139         subset1 = psImageSubset(original,psRegionSet(0,c*2,0,r/2));
    140         ok(subset1 == NULL,
    141            "psImageSubset returned NULL when subset origin was outside of image (via rows)");
    142         // An error should follow...
    143         // XXX: Verify error
    144         subset1 = psImageSubset(original, psRegionSet(-1,c/2,0,r/2));
    145         ok(subset1 == NULL,
    146            "psImageSubset returned NULL when subset origin was outside of image (col0=-1)");
    147         // An error should follow...
    148         // XXX: Verify error
    149         subset1 = psImageSubset(original, psRegionSet(0,c/2,-1,r/2));
    150         ok(subset1 == NULL,
    151            "psImageSubset returned NULL when subset origin was outside of image (row0=-1)");
    152 
     132        {
     133            subset1 = psImageSubset(original, psRegionSet(0,numCols/2, 0,numRows*2));
     134            ok(subset1 == NULL,
     135               "psImageSubset returned NULL when subset origin was outside of image (via cols)");
     136            // An error should follow...
     137            // XXX: Verify error
     138            subset1 = psImageSubset(original,psRegionSet(0,numCols*2,0,numRows/2));
     139            ok(subset1 == NULL,
     140               "psImageSubset returned NULL when subset origin was outside of image (via rows)");
     141            // An error should follow...
     142            // XXX: Verify error
     143            subset1 = psImageSubset(original, psRegionSet(-1,numCols/2,0,numRows/2));
     144            ok(subset1 == NULL,
     145               "psImageSubset returned NULL when subset origin was outside of image (col0=-1)");
     146            // An error should follow...
     147            // XXX: Verify error
     148            subset1 = psImageSubset(original, psRegionSet(0,numCols/2,-1,numRows/2));
     149            ok(subset1 == NULL,
     150               "psImageSubset returned NULL when subset origin was outside of image (row0=-1)");
     151        }   
    153152
    154153        // Verify the returned psImage structure pointer is null and program
    … …  
    158157        // An error should follow...
    159158        // XXX: Verify error
    160         subset1 = psImageSubset(original,psRegionSet(0,c/2,0,r+1));
    161         ok(subset1 == NULL,
    162            "psImageSubset returned NULL when subset was outside of image (via rows)");
    163         // An error should follow...
    164         // XXX: Verify error
    165         subset1 = psImageSubset(original, psRegionSet(0,c+1,0,r/2));
    166         ok(subset1 == NULL,
    167            "psImageSubset returned NULL when subset was outside of image (via cols)");
    168         // An error should follow...
    169         // XXX: Verify error
    170         subset1 = psImageSubset(original,psRegionSet(0,c+1,0,r+1));
    171         ok(subset1 == NULL,
    172            "psImageSubset returned NULL when subset was outside of image (via row+cols)");
    173 
     159        {
     160            subset1 = psImageSubset(original,psRegionSet(0,numCols/2,0,numRows+1));
     161            ok(subset1 == NULL,
     162               "psImageSubset returned NULL when subset was outside of image (via rows)");
     163            // An error should follow...
     164            // XXX: Verify error
     165            subset1 = psImageSubset(original, psRegionSet(0,numCols+1,0,numRows/2));
     166            ok(subset1 == NULL,
     167               "psImageSubset returned NULL when subset was outside of image (via cols)");
     168            // An error should follow...
     169            // XXX: Verify error
     170            subset1 = psImageSubset(original,psRegionSet(0,numCols+1,0,numRows+1));
     171            ok(subset1 == NULL,
     172               "psImageSubset returned NULL when subset was outside of image (via row+cols)");
     173        }
    174174
    175175        // psImageFreeChildren shall deallocate any children images of a
    … …  
    196196        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    197197    }
     198}
     199
     200psS32 main(psS32 argc, char* argv[])
     201{
     202    psLogSetFormat("HLNM");
     203    psLogSetLevel(PS_LOG_INFO);
     204    plan_tests(239);
     205
     206    genericImageSubsetTest(128, 256);
     207    genericImageSubsetTest(256, 128);
     208    genericImageSubsetTest(128, 128);
    198209
    199210    // psImageCopy()
Note: See TracChangeset for help on using the changeset viewer.