IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11397


Ignore:
Timestamp:
Jan 29, 2007, 2:11:31 PM (19 years ago)
Author:
gusciora
Message:

Improved skip macro placement for the PolyEval files.

Fist version of tap_psMatrixVectorArithmetic01.c

Location:
trunk/psLib/test/math
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/math/tap_psPolynomialEval1D.c

    r11374 r11397  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2007-01-29 21:32:50 $
     6*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2007-01-30 00:11:31 $
    88*
    99*  XXX: Probably should test single- and multi-dimensional polynomials in
    … …  
    7373        }
    7474        ok(!errorFlag, "psPolynomial1DEval() successful (Ordinary)");
    75 
     75        skip_end();
    7676        psFree(polyOrd);
    77         skip_end();
    7877        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    7978    }
    … …  
    8584        psPolynomial1D*  polyCheb = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1);
    8685        ok(polyCheb != NULL, "Chebyshev psPolynomial1D successfully allocated");
    87         skip_start(polyCheb == NULL, 2, "Skipping tests because psPolynomial1DAlloc() failed");
    88 
     86        skip_start(polyCheb == NULL, 1, "Skipping tests because psPolynomial1DAlloc() failed");
    8987        // Set polynomial members
    9088        for(psS32 i = 0; i < TERMS; i++)
    … …  
    103101        }
    104102        ok(!errorFlag, "psPolynomial1DEval() successful (Chebyshev)");
     103        skip_end();
    105104        psFree(polyCheb);
    106         skip_end();
    107105        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    108106    }
    … …  
    127125    {
    128126        psMemId id = psMemGetId();
     127        // Create input vectors
     128        psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
     129        for(psS32 i = 0; i < TESTPOINTS; i++)
     130        {
     131            inputOrd->data.F64[i] = poly1DXValue[i];
     132            inputOrd->n++;
     133        }
     134
    129135        psPolynomial1D* polyOrd = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, TERMS-1);
    130136        ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
    131137        skip_start(polyOrd == NULL, 6, "Skipping tests because psPolynomial1DAlloc() failed");
    132 
    133138        // Set polynomial members
    134139        for(psS32 i = 0; i < TERMS; i++)
    … …  
    136141            polyOrd->coeff[i] = poly1DCoeff[i];
    137142            polyOrd->mask[i]  = poly1DMask[i];
    138         }
    139 
    140         // Create input vectors
    141         psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    142         for(psS32 i = 0; i < TESTPOINTS; i++)
    143         {
    144             inputOrd->data.F64[i] = poly1DXValue[i];
    145             inputOrd->n++;
    146143        }
    147144
    … …  
    172169        inputOrd->type.type = PS_TYPE_U8;
    173170        ok(psPolynomial1DEvalVector(polyOrd,inputOrd) == NULL, "psPolynomial1DEvalVector() produced NULL when called with non F64 input vector");
    174 
     171        psFree(outputOrd);
     172        skip_end();
    175173        psFree(inputOrd);
    176         psFree(outputOrd);
    177174        psFree(polyOrd);
    178 
    179         skip_end();
    180175        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    181176    }
    … …  
    184179    {
    185180        psMemId id = psMemGetId();
     181        // Create input vectors
     182        psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
     183        for(psS32 i = 0; i < TESTPOINTS; i++)
     184        {
     185            inputCheb->data.F64[i] = poly1DXChebValue[i];
     186            inputCheb->n++;
     187        }
     188
    186189        psPolynomial1D* polyCheb = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1);
    187190        ok(polyCheb != NULL, "Ordinary polynomial allocation successful");
    188         skip_start(polyCheb == NULL, 6, "Skipping tests because psPolynomial1DAlloc() failed");
    189 
     191        skip_start(polyCheb == NULL, 5, "Skipping tests because psPolynomial1DAlloc() failed");
    190192        // Set polynomial members
    191193        for(psS32 i = 0; i < TERMS; i++)
    … …  
    193195            polyCheb->coeff[i] = 1.0;
    194196            polyCheb->mask[i]  = poly1DMask[i];
    195         }
    196 
    197         // Create input vectors
    198         psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    199         for(psS32 i = 0; i < TESTPOINTS; i++)
    200         {
    201             inputCheb->data.F64[i] = poly1DXChebValue[i];
    202             inputCheb->n++;
    203197        }
    204198
    … …  
    226220        inputCheb->type.type = PS_TYPE_U8;
    227221        ok(psPolynomial1DEvalVector(polyCheb,inputCheb) == NULL, "psPolynomial1DEvalVector() produced NULL when called with non F64 input vector");
    228 
     222        psFree(outputCheb);
     223        skip_end();
    229224        psFree(inputCheb);
    230         psFree(outputCheb);
    231225        psFree(polyCheb);
    232         skip_end();
    233226        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    234227    }

  • trunk/psLib/test/math/tap_psPolynomialEval2D.c

    r10848 r11397  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-12-29 04:38:42 $
     6*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2007-01-30 00:11:31 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    101101        }
    102102        ok(!errorFlag, "psPolynomial2DEval() successful (Ordinary)");
    103 
     103        skip_end();
    104104        psFree(polyOrd);
    105         skip_end();
    106105        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    107106    }
    … …  
    137136        }
    138137        ok(!errorFlag, "psPolynomial2DEval() successful (Chebyshev)");
    139 
     138        skip_end();
    140139        psFree(polyCheb);
    141         skip_end();
    142140        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    143141    }
    … …  
    148146        psMemId id = psMemGetId();
    149147        psPolynomial2D* polyOrd = psPolynomial2DAlloc(99, TERMS-1, TERMS-1);
    150         ok(polyOrd == NULL, "Ordinary polynomial allocation successful");
     148        ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
    151149        skip_start(polyOrd == NULL, 1, "Skipping tests because psPolynomial2DAlloc() failed");
    152 
    153         // Attempt to evaluation invalid polynomial type
     150        // Attempt to evaluate invalid polynomial type
    154151        psF64 result = psPolynomial2DEval(polyOrd,0.0, 0.0);
    155152        ok(isnan(result), "psPolynomial2DEval() did not return NAN, as expected");
    156 
    157153        skip_end();
    158154        psFree(polyOrd);
    159 
    160155        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    161156    }
    … …  
    165160    {
    166161        psMemId id = psMemGetId();
    167         psPolynomial2D* polyOrd = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1);
    168         ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
    169         skip_start(polyOrd == NULL, 8, "Skipping tests because psPolynomial2DAlloc() failed");
    170 
    171         // Set polynomial members
    172         for(psS32 i = 0; i < TERMS; i++)
    173         {
    174             for(psS32 j = 0; j < TERMS; j++) {
    175                 polyOrd->coeff[i][j] = poly2DCoeff[i][j];
    176                 polyOrd->mask[i][j]  = poly2DMask[i][j];
    177             }
    178         }
    179 
    180162        // Create input vectors
    181163        psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    189171        }
    190172
     173        psPolynomial2D* polyOrd = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1);
     174        ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
     175        skip_start(polyOrd == NULL, 8, "Skipping tests because psPolynomial2DAlloc() failed");
     176        // Set polynomial members
     177        for(psS32 i = 0; i < TERMS; i++)
     178        {
     179            for(psS32 j = 0; j < TERMS; j++) {
     180                polyOrd->coeff[i][j] = poly2DCoeff[i][j];
     181                polyOrd->mask[i][j]  = poly2DMask[i][j];
     182            }
     183        }
     184
    191185        // Evaluate the vectors
    192186        psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
    … …  
    223217        inputOrdY->type.type = PS_TYPE_U8;
    224218        ok(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) == NULL, "psPolynomial2DEvalVector() produced NULL when called with non F64 input vector");
    225 
     219        psFree(outputOrd);
     220        skip_end();
    226221        psFree(inputOrdX);
    227222        psFree(inputOrdY);
    228         psFree(outputOrd);
    229223        psFree(polyOrd);
    230 
    231         skip_end();
    232224        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    233225
    … …  
    241233    {
    242234        psMemId id = psMemGetId();
    243         psPolynomial2D* polyCheb = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1);
    244         ok(polyCheb != NULL, "Cheby polynomial allocation successful");
    245         skip_start(polyCheb == NULL, 8, "Skipping tests because psPolynomial2DAlloc() failed");
    246 
    247         // Set polynomial members
    248         for(psS32 i = 0; i < TERMS; i++)
    249         {
    250             for(psS32 j = 0; j < TERMS; j++) {
    251                 polyCheb->coeff[i][j] = 1.0;
    252                 polyCheb->mask[i][j]  = poly2DMask[i][j];
    253             }
    254         }
    255 
    256235        // Create input vectors
    257236        psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    265244        }
    266245
     246        psPolynomial2D* polyCheb = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1);
     247        ok(polyCheb != NULL, "Cheby polynomial allocation successful");
     248        skip_start(polyCheb == NULL, 8, "Skipping tests because psPolynomial2DAlloc() failed");
     249        // Set polynomial members
     250        for(psS32 i = 0; i < TERMS; i++)
     251        {
     252            for(psS32 j = 0; j < TERMS; j++) {
     253                polyCheb->coeff[i][j] = 1.0;
     254                polyCheb->mask[i][j]  = poly2DMask[i][j];
     255            }
     256        }
     257
    267258        // Evaluate the vectors
    268259        psVector* outputCheb = psPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
    … …  
    300291        inputChebY->type.type = PS_TYPE_U8;
    301292        ok(psPolynomial2DEvalVector(polyCheb,inputChebX, inputChebY) == NULL, "psPolynomial2DEvalVector() produced NULL when called with non F64 input vector");
    302 
     293        psFree(outputCheb);
     294        skip_end();
    303295        psFree(inputChebX);
    304296        psFree(inputChebY);
    305         psFree(outputCheb);
    306297        psFree(polyCheb);
    307 
    308         skip_end();
    309298        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    310299    }

  • trunk/psLib/test/math/tap_psPolynomialEval3D.c

    r10848 r11397  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-12-29 04:38:42 $
     6*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2007-01-30 00:11:31 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    207207        psMemId id = psMemGetId();
    208208        psPolynomial3D* polyOrd = psPolynomial3DAlloc(99, TERMS-1, TERMS-1, TERMS-1);
    209         ok(polyOrd == NULL, "Ordinary polynomial allocation successful");
     209        ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
    210210        skip_start(polyOrd == NULL, 1, "Skipping tests because psPolynomial3DAlloc() failed");
    211 
    212211        // Attempt to evaluation invalid polynomial type
    213212        psF64 result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
    … …  
    222221    {
    223222        psMemId id = psMemGetId();
    224         psPolynomial3D* polyOrd = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1);
    225         ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
    226         skip_start(polyOrd == NULL, 8, "Skipping tests because psPolynomial3DAlloc() failed");
    227 
    228         // Set polynomial members
    229         for(psS32 i = 0; i < TERMS; i++)
    230         {
    231             for(psS32 j = 0; j < TERMS; j++) {
    232                 for(psS32 k = 0; k < TERMS; k++) {
    233                     polyOrd->coeff[i][j][k] = Dpoly3DCoeff[i][j][k];
    234                     polyOrd->mask[i][j][k]  = poly3DMask[i][j][k];
    235                 }
    236             }
    237         }
    238 
    239223        // Create input vectors
    240224        psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    251235        }
    252236
     237        psPolynomial3D* polyOrd = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1);
     238        ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
     239        skip_start(polyOrd == NULL, 10, "Skipping tests because psPolynomial3DAlloc() failed");
     240        // Set polynomial members
     241        for(psS32 i = 0; i < TERMS; i++)
     242        {
     243            for(psS32 j = 0; j < TERMS; j++) {
     244                for(psS32 k = 0; k < TERMS; k++) {
     245                    polyOrd->coeff[i][j][k] = Dpoly3DCoeff[i][j][k];
     246                    polyOrd->mask[i][j][k]  = poly3DMask[i][j][k];
     247                }
     248            }
     249        }
     250
    253251        // Evaluate the vectors
    254252        psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
    … …  
    293291        inputOrdZ->type.type = PS_TYPE_U8;
    294292        ok(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial3DEvalVector() produced NULL when called with non F64 input vector");
    295 
     293        psFree(outputOrd);
     294        skip_end();
    296295        psFree(inputOrdX);
    297296        psFree(inputOrdY);
    298297        psFree(inputOrdZ);
    299         psFree(outputOrd);
    300298        psFree(polyOrd);
    301         skip_end();
    302299        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    303300    }
    … …  
    309306    {
    310307        psMemId id = psMemGetId();
    311         psPolynomial3D* polyCheb = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1);
    312         ok(polyCheb != NULL, "Ordinary polynomial allocation successful");
    313         skip_start(polyCheb == NULL, 8, "Skipping tests because psPolynomial3DAlloc() failed");
    314 
    315         // Set polynomial members
    316         for(psS32 i = 0; i < TERMS; i++)
    317         {
    318             for(psS32 j = 0; j < TERMS; j++) {
    319                 for(psS32 k = 0; k < TERMS; k++) {
    320                     polyCheb->coeff[i][j][k] = 1.0;
    321                     polyCheb->mask[i][j][k]  = poly3DMask[i][j][k];
    322                 }
    323             }
    324         }
    325 
    326308        // Create input vectors
    327309        psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    337319            inputChebZ->n++;
    338320        }
     321        psPolynomial3D* polyCheb = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1);
     322        ok(polyCheb != NULL, "Ordinary polynomial allocation successful");
     323        skip_start(polyCheb == NULL, 10, "Skipping tests because psPolynomial3DAlloc() failed");
     324        // Set polynomial members
     325        for(psS32 i = 0; i < TERMS; i++)
     326        {
     327            for(psS32 j = 0; j < TERMS; j++) {
     328                for(psS32 k = 0; k < TERMS; k++) {
     329                    polyCheb->coeff[i][j][k] = 1.0;
     330                    polyCheb->mask[i][j][k]  = poly3DMask[i][j][k];
     331                }
     332            }
     333        }
    339334
    340335        // Evaluate the vectors
    … …  
    380375        inputChebZ->type.type = PS_TYPE_U8;
    381376        ok(psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial3DEvalVector() produced NULL when called with non F64 input vector");
    382 
     377        psFree(outputCheb);
     378        skip_end();
    383379        psFree(inputChebX);
    384380        psFree(inputChebY);
    385381        psFree(inputChebZ);
    386         psFree(outputCheb);
    387382        psFree(polyCheb);
    388         skip_end();
    389383        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    390384    }

  • trunk/psLib/test/math/tap_psPolynomialEval4D.c

    r10848 r11397  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-12-29 04:38:42 $
     6*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2007-01-30 00:11:31 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    462462    {
    463463        psMemId id = psMemGetId();
    464         // Allocate polynomial
    465         psPolynomial4D* polyOrd = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
    466         ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
    467         skip_start(polyOrd == NULL, 8, "Skipping tests because psPolynomial4DAlloc() failed");
    468 
    469         // Set polynomial members
    470         for(psS32 i = 0; i < TERMS; i++)
    471         {
    472             for(psS32 j = 0; j < TERMS; j++) {
    473                 for(psS32 k = 0; k < TERMS; k++) {
    474                     for(psS32 l = 0; l < TERMS; l++) {
    475                         polyOrd->coeff[i][j][k][l] = Dpoly4DCoeff[i][j][k][l];
    476                         polyOrd->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
    477                     }
    478                 }
    479             }
    480         }
    481 
    482464        // Create input vectors
    483465        psVector* inputOrdW  = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    497479        }
    498480
     481        // Allocate polynomial
     482        psPolynomial4D* polyOrd = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
     483        ok(polyOrd != NULL, "Ordinary polynomial allocation successful");
     484        skip_start(polyOrd == NULL, 12, "Skipping tests because psPolynomial4DAlloc() failed");
     485        // Set polynomial members
     486        for(psS32 i = 0; i < TERMS; i++)
     487        {
     488            for(psS32 j = 0; j < TERMS; j++) {
     489                for(psS32 k = 0; k < TERMS; k++) {
     490                    for(psS32 l = 0; l < TERMS; l++) {
     491                        polyOrd->coeff[i][j][k][l] = Dpoly4DCoeff[i][j][k][l];
     492                        polyOrd->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
     493                    }
     494                }
     495            }
     496        }
     497
    499498        // Evaluate the vectors
    500499        psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
    … …  
    548547        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
    549548        inputOrdW->type.type = PS_TYPE_F64;
    550 
     549        psFree(outputOrd);
     550        skip_end();
    551551        psFree(inputOrdX);
    552552        psFree(inputOrdY);
    553553        psFree(inputOrdZ);
    554554        psFree(inputOrdW);
    555         psFree(outputOrd);
    556555        psFree(polyOrd);
    557 
    558         skip_end();
    559556        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    560557    }
    … …  
    563560    {
    564561        psMemId id = psMemGetId();
    565         // Allocate polynomial
    566         psPolynomial4D* polyCheb = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
    567         ok(polyCheb != NULL, "Ordinary polynomial allocation successful");
    568         skip_start(polyCheb == NULL, 8, "Skipping tests because psPolynomial4DAlloc() failed");
    569 
    570         // Set polynomial members
    571         for(psS32 i = 0; i < TERMS; i++)
    572         {
    573             for(psS32 j = 0; j < TERMS; j++) {
    574                 for(psS32 k = 0; k < TERMS; k++) {
    575                     for(psS32 l = 0; l < TERMS; l++) {
    576                         polyCheb->coeff[i][j][k][l] = 1.0;
    577                         polyCheb->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
    578                     }
    579                 }
    580             }
    581         }
    582 
    583562        // Create input vectors
    584563        psVector* inputChebW = psVectorAlloc(TESTPOINTS, PS_TYPE_F64);
    … …  
    598577        }
    599578
     579        // Allocate polynomial
     580        psPolynomial4D* polyCheb = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
     581        ok(polyCheb != NULL, "Ordinary polynomial allocation successful");
     582        skip_start(polyCheb == NULL, 12, "Skipping tests because psPolynomial4DAlloc() failed");
     583
     584        // Set polynomial members
     585        for(psS32 i = 0; i < TERMS; i++)
     586        {
     587            for(psS32 j = 0; j < TERMS; j++) {
     588                for(psS32 k = 0; k < TERMS; k++) {
     589                    for(psS32 l = 0; l < TERMS; l++) {
     590                        polyCheb->coeff[i][j][k][l] = 1.0;
     591                        polyCheb->mask[i][j][k][l]  = poly4DMask[i][j][k][l];
     592                    }
     593                }
     594            }
     595        }
     596
    600597        // Evaluate the vectors
    601598        psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
    … …  
    649646        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
    650647        inputChebW->type.type = PS_TYPE_F64;
    651 
     648        psFree(outputCheb);
     649        skip_end();
    652650        psFree(inputChebW);
    653651        psFree(inputChebX);
    654652        psFree(inputChebY);
    655653        psFree(inputChebZ);
    656         psFree(outputCheb);
    657654        psFree(polyCheb);
    658 
    659         skip_end();
    660655        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    661656    }
Note: See TracChangeset for help on using the changeset viewer.