test/testautomation_render.c

   1 /**
   2  * Original code: automated SDL platform test written by Edgar Simo "bobbens"
   3  * Extended and extensively updated by aschiffler at ferzkopp dot net
   4  */
   5
   6 #include <stdio.h>
   7
   8 #include "SDL.h"
   9 #include "SDL_test.h"
  10
  11 /* ================= Test Case Implementation ================== */
  12
  13 #define TESTRENDER_SCREEN_W     80
  14 #define TESTRENDER_SCREEN_H     60
  15
  16 #define RENDER_COMPARE_FORMAT  SDL_PIXELFORMAT_ARGB8888
  17 #define RENDER_COMPARE_AMASK   0xff000000 /**< Alpha bit mask. */
  18 #define RENDER_COMPARE_RMASK   0x00ff0000 /**< Red bit mask. */
  19 #define RENDER_COMPARE_GMASK   0x0000ff00 /**< Green bit mask. */
  20 #define RENDER_COMPARE_BMASK   0x000000ff /**< Blue bit mask. */
  21
  22 #define ALLOWABLE_ERROR_OPAQUE  0
  23 #define ALLOWABLE_ERROR_BLENDED 64
  24
  25 /* Test window and renderer */
  26 SDL_Window *window = NULL;
  27 SDL_Renderer *renderer = NULL;
  28
  29 /* Prototypes for helper functions */
  30
  31 static int _clearScreen (void);
  32 static void _compare(SDL_Surface *reference, int allowable_error);
  33 static int _hasTexAlpha(void);
  34 static int _hasTexColor(void);
  35 static SDL_Texture *_loadTestFace(void);
  36 static int _hasBlendModes(void);
  37 static int _hasDrawColor(void);
  38 static int _isSupported(int code);
  39
  40 /**
  41  * Create software renderer for tests
  42  */
  43 void InitCreateRenderer(void *arg)
  44 {
  45   int posX = 100, posY = 100, width = 320, height = 240;
  46   renderer = NULL;
  47   window = SDL_CreateWindow("render_testCreateRenderer", posX, posY, width, height, SDL_WINDOW_FULLSCREEN);
  48   SDLTest_AssertPass("SDL_CreateWindow()");
  49   SDLTest_AssertCheck(window != NULL, "Check SDL_CreateWindow result");
  50   if (window == NULL) {
  51       return;
  52   }
  53
  54   renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
  55   SDLTest_AssertPass("SDL_CreateRenderer()");
  56   SDLTest_AssertCheck(renderer != 0, "Check SDL_CreateRenderer result");
  57   if (renderer == NULL) {
  58       SDL_DestroyWindow(window);
  59       return;
  60   }
  61 }
  62
  63 /*
  64  * Destroy renderer for tests
  65  */
  66 void CleanupDestroyRenderer(void *arg)
  67 {
  68   if (renderer != NULL) {
  69      SDL_DestroyRenderer(renderer);
  70      renderer = NULL;
  71      SDLTest_AssertPass("SDL_DestroyRenderer()");
  72   }
  73
  74   if (window != NULL) {
  75      SDL_DestroyWindow(window);
  76      window = NULL;
  77      SDLTest_AssertPass("SDL_DestroyWindow");
  78   }
  79 }
  80
  81
  82 /**
  83  * @brief Tests call to SDL_GetNumRenderDrivers
  84  *
  85  * \sa
  86  * http://wiki.libsdl.org/moin.cgi/SDL_GetNumRenderDrivers
  87  */
  88 int
  89 render_testGetNumRenderDrivers(void *arg)
  90 {
  91   int n;
  92   n = SDL_GetNumRenderDrivers();
  93   SDLTest_AssertCheck(n >= 1, "Number of renderers >= 1, reported as %i", n);
  94   return TEST_COMPLETED;
  95 }
  96
  97
  98 /**
  99  * @brief Tests the SDL primitives for rendering.
 100  *
 101  * \sa
 102  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
 103  * http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
 104  * http://wiki.libsdl.org/moin.cgi/SDL_RenderDrawLine
 105  *
 106  */
 107 int render_testPrimitives (void *arg)
 108 {
 109    int ret;
 110    int x, y;
 111    SDL_Rect rect;
 112    SDL_Surface *referenceSurface = NULL;
 113    int checkFailCount1;
 114    int checkFailCount2;
 115
 116    /* Clear surface. */
 117    _clearScreen();
 118
 119    /* Need drawcolor or just skip test. */
 120    SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
 121
 122    /* Draw a rectangle. */
 123    rect.x = 40;
 124    rect.y = 0;
 125    rect.w = 40;
 126    rect.h = 80;
 127
 128    ret = SDL_SetRenderDrawColor(renderer, 13, 73, 200, SDL_ALPHA_OPAQUE );
 129    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 130
 131    ret = SDL_RenderFillRect(renderer, &rect );
 132    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
 133
 134    /* Draw a rectangle. */
 135    rect.x = 10;
 136    rect.y = 10;
 137    rect.w = 60;
 138    rect.h = 40;
 139    ret = SDL_SetRenderDrawColor(renderer, 200, 0, 100, SDL_ALPHA_OPAQUE );
 140    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 141
 142    ret = SDL_RenderFillRect(renderer, &rect );
 143    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
 144
 145    /* Draw some points like so:
 146     * X.X.X.X..
 147     * .X.X.X.X.
 148     * X.X.X.X.. */
 149    checkFailCount1 = 0;
 150    checkFailCount2 = 0;
 151    for (y=0; y<3; y++) {
 152       for (x = y % 2; x<TESTRENDER_SCREEN_W; x+=2) {
 153          ret = SDL_SetRenderDrawColor(renderer, x*y, x*y/2, x*y/3, SDL_ALPHA_OPAQUE );
 154          if (ret != 0) checkFailCount1++;
 155
 156          ret = SDL_RenderDrawPoint(renderer, x, y );
 157          if (ret != 0) checkFailCount2++;
 158       }
 159    }
 160    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
 161    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount2);
 162
 163    /* Draw some lines. */
 164    ret = SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE );
 165    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor");
 166
 167    ret = SDL_RenderDrawLine(renderer, 0, 30, TESTRENDER_SCREEN_W, 30 );
 168    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
 169
 170    ret = SDL_SetRenderDrawColor(renderer, 55, 55, 5, SDL_ALPHA_OPAQUE );
 171    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 172
 173    ret = SDL_RenderDrawLine(renderer, 40, 30, 40, 60 );
 174    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
 175
 176    ret = SDL_SetRenderDrawColor(renderer, 5, 105, 105, SDL_ALPHA_OPAQUE );
 177    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 178
 179    ret = SDL_RenderDrawLine(renderer, 0, 0, 29, 29 );
 180    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
 181
 182    ret = SDL_RenderDrawLine(renderer, 29, 30, 0, 59 );
 183    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
 184
 185    ret = SDL_RenderDrawLine(renderer, 79, 0, 50, 29 );
 186    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
 187
 188    ret = SDL_RenderDrawLine(renderer, 79, 59, 50, 30 );
 189    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
 190
 191    /* Make current */
 192    SDL_RenderPresent(renderer);
 193
 194    /* See if it's the same. */
 195    referenceSurface = SDLTest_ImagePrimitives();
 196    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 197
 198    /* Clean up. */
 199    SDL_FreeSurface(referenceSurface);
 200    referenceSurface = NULL;
 201
 202    return TEST_COMPLETED;
 203 }
 204
 205 /**
 206  * @brief Tests the SDL primitives with alpha for rendering.
 207  *
 208  * \sa
 209  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
 210  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
 211  * http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
 212  */
 213 int render_testPrimitivesBlend (void *arg)
 214 {
 215    int ret;
 216    int i, j;
 217    SDL_Rect rect;
 218    SDL_Surface *referenceSurface = NULL;
 219    int checkFailCount1;
 220    int checkFailCount2;
 221    int checkFailCount3;
 222
 223    /* Clear surface. */
 224    _clearScreen();
 225
 226    /* Need drawcolor and blendmode or just skip test. */
 227    SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
 228    SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
 229
 230    /* Create some rectangles for each blend mode. */
 231    ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0 );
 232    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 233
 234    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
 235    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
 236
 237    ret = SDL_RenderFillRect(renderer, NULL );
 238    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
 239
 240    rect.x = 10;
 241    rect.y = 25;
 242    rect.w = 40;
 243    rect.h = 25;
 244    ret = SDL_SetRenderDrawColor(renderer, 240, 10, 10, 75 );
 245    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 246
 247    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD );
 248    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
 249
 250    ret = SDL_RenderFillRect(renderer, &rect );
 251    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
 252
 253    rect.x = 30;
 254    rect.y = 40;
 255    rect.w = 45;
 256    rect.h = 15;
 257    ret = SDL_SetRenderDrawColor(renderer, 10, 240, 10, 100 );
 258    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 259
 260    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND );
 261    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
 262
 263    ret = SDL_RenderFillRect(renderer, &rect );
 264    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
 265
 266    rect.x = 25;
 267    rect.y = 25;
 268    rect.w = 25;
 269    rect.h = 25;
 270    ret = SDL_SetRenderDrawColor(renderer, 10, 10, 240, 125 );
 271    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
 272
 273    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
 274    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
 275
 276    ret = SDL_RenderFillRect(renderer, &rect );
 277    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
 278
 279
 280    /* Draw blended lines, lines for everyone. */
 281    checkFailCount1 = 0;
 282    checkFailCount2 = 0;
 283    checkFailCount3 = 0;
 284    for (i=0; i<TESTRENDER_SCREEN_W; i+=2)  {
 285       ret = SDL_SetRenderDrawColor(renderer, 60+2*i, 240-2*i, 50, 3*i );
 286       if (ret != 0) checkFailCount1++;
 287
 288       ret = SDL_SetRenderDrawBlendMode(renderer,(((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
 289             (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
 290       if (ret != 0) checkFailCount2++;
 291
 292       ret = SDL_RenderDrawLine(renderer, 0, 0, i, 59 );
 293       if (ret != 0) checkFailCount3++;
 294    }
 295    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
 296    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
 297    SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawLine, expected: 0, got: %i", checkFailCount3);
 298
 299    checkFailCount1 = 0;
 300    checkFailCount2 = 0;
 301    checkFailCount3 = 0;
 302    for (i=0; i<TESTRENDER_SCREEN_H; i+=2)  {
 303       ret = SDL_SetRenderDrawColor(renderer, 60+2*i, 240-2*i, 50, 3*i );
 304       if (ret != 0) checkFailCount1++;
 305
 306       ret = SDL_SetRenderDrawBlendMode(renderer,(((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
 307             (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
 308       if (ret != 0) checkFailCount2++;
 309
 310       ret = SDL_RenderDrawLine(renderer, 0, 0, 79, i );
 311       if (ret != 0) checkFailCount3++;
 312    }
 313    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
 314    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
 315    SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawLine, expected: 0, got: %i", checkFailCount3);
 316
 317    /* Draw points. */
 318    checkFailCount1 = 0;
 319    checkFailCount2 = 0;
 320    checkFailCount3 = 0;
 321    for (j=0; j<TESTRENDER_SCREEN_H; j+=3) {
 322       for (i=0; i<TESTRENDER_SCREEN_W; i+=3) {
 323          ret = SDL_SetRenderDrawColor(renderer, j*4, i*3, j*4, i*3 );
 324          if (ret != 0) checkFailCount1++;
 325
 326          ret = SDL_SetRenderDrawBlendMode(renderer, ((((i+j)/3)%3)==0) ? SDL_BLENDMODE_BLEND :
 327                ((((i+j)/3)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
 328          if (ret != 0) checkFailCount2++;
 329
 330          ret = SDL_RenderDrawPoint(renderer, i, j );
 331          if (ret != 0) checkFailCount3++;
 332       }
 333    }
 334    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
 335    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
 336    SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount3);
 337
 338    /* Make current */
 339    SDL_RenderPresent(renderer);
 340
 341    /* See if it's the same. */
 342    referenceSurface = SDLTest_ImagePrimitivesBlend();
 343    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 344
 345    /* Clean up. */
 346    SDL_FreeSurface(referenceSurface);
 347    referenceSurface = NULL;
 348
 349    return TEST_COMPLETED;
 350 }
 351
 352
 353
 354 /**
 355  * @brief Tests some blitting routines.
 356  *
 357  * \sa
 358  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
 359  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
 360  */
 361 int
 362 render_testBlit(void *arg)
 363 {
 364    int ret;
 365    SDL_Rect rect;
 366    SDL_Texture *tface;
 367    SDL_Surface *referenceSurface = NULL;
 368    Uint32 tformat;
 369    int taccess, tw, th;
 370    int i, j, ni, nj;
 371    int checkFailCount1;
 372
 373    /* Clear surface. */
 374    _clearScreen();
 375
 376    /* Need drawcolor or just skip test. */
 377    SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor)");
 378
 379    /* Create face surface. */
 380    tface = _loadTestFace();
 381    SDLTest_AssertCheck(tface != NULL,  "Verify _loadTestFace() result");
 382    if (tface == NULL) {
 383        return TEST_ABORTED;
 384    }
 385
 386    /* Constant values. */
 387    ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
 388    SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
 389    rect.w = tw;
 390    rect.h = th;
 391    ni     = TESTRENDER_SCREEN_W - tw;
 392    nj     = TESTRENDER_SCREEN_H - th;
 393
 394    /* Loop blit. */
 395    checkFailCount1 = 0;
 396    for (j=0; j <= nj; j+=4) {
 397       for (i=0; i <= ni; i+=4) {
 398          /* Blitting. */
 399          rect.x = i;
 400          rect.y = j;
 401          ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
 402          if (ret != 0) checkFailCount1++;
 403       }
 404    }
 405    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount1);
 406
 407    /* Make current */
 408    SDL_RenderPresent(renderer);
 409
 410    /* See if it's the same */
 411    referenceSurface = SDLTest_ImageBlit();
 412    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 413
 414    /* Clean up. */
 415    SDL_DestroyTexture( tface );
 416    SDL_FreeSurface(referenceSurface);
 417    referenceSurface = NULL;
 418
 419    return TEST_COMPLETED;
 420 }
 421
 422
 423 /**
 424  * @brief Blits doing color tests.
 425  *
 426  * \sa
 427  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
 428  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
 429  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
 430  */
 431 int
 432 render_testBlitColor (void *arg)
 433 {
 434    int ret;
 435    SDL_Rect rect;
 436    SDL_Texture *tface;
 437    SDL_Surface *referenceSurface = NULL;
 438    Uint32 tformat;
 439    int taccess, tw, th;
 440    int i, j, ni, nj;
 441    int checkFailCount1;
 442    int checkFailCount2;
 443
 444    /* Clear surface. */
 445    _clearScreen();
 446
 447    /* Create face surface. */
 448    tface = _loadTestFace();
 449    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
 450    if (tface == NULL) {
 451        return TEST_ABORTED;
 452    }
 453
 454    /* Constant values. */
 455    ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
 456    SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
 457    rect.w = tw;
 458    rect.h = th;
 459    ni     = TESTRENDER_SCREEN_W - tw;
 460    nj     = TESTRENDER_SCREEN_H - th;
 461
 462    /* Test blitting with color mod. */
 463    checkFailCount1 = 0;
 464    checkFailCount2 = 0;
 465    for (j=0; j <= nj; j+=4) {
 466       for (i=0; i <= ni; i+=4) {
 467          /* Set color mod. */
 468          ret = SDL_SetTextureColorMod( tface, (255/nj)*j, (255/ni)*i, (255/nj)*j );
 469          if (ret != 0) checkFailCount1++;
 470
 471          /* Blitting. */
 472          rect.x = i;
 473          rect.y = j;
 474          ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
 475          if (ret != 0) checkFailCount2++;
 476       }
 477    }
 478    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1);
 479    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
 480
 481    /* Make current */
 482    SDL_RenderPresent(renderer);
 483
 484    /* See if it's the same. */
 485    referenceSurface = SDLTest_ImageBlitColor();
 486    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 487
 488    /* Clean up. */
 489    SDL_DestroyTexture( tface );
 490    SDL_FreeSurface(referenceSurface);
 491    referenceSurface = NULL;
 492
 493    return TEST_COMPLETED;
 494 }
 495
 496
 497 /**
 498  * @brief Tests blitting with alpha.
 499  *
 500  * \sa
 501  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
 502  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
 503  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
 504  */
 505 int
 506 render_testBlitAlpha (void *arg)
 507 {
 508    int ret;
 509    SDL_Rect rect;
 510    SDL_Texture *tface;
 511    SDL_Surface *referenceSurface = NULL;
 512    Uint32 tformat;
 513    int taccess, tw, th;
 514    int i, j, ni, nj;
 515    int checkFailCount1;
 516    int checkFailCount2;
 517
 518    /* Clear surface. */
 519    _clearScreen();
 520
 521    /* Need alpha or just skip test. */
 522    SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
 523
 524    /* Create face surface. */
 525    tface = _loadTestFace();
 526    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
 527    if (tface == NULL) {
 528        return TEST_ABORTED;
 529    }
 530
 531    /* Constant values. */
 532    ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
 533    SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
 534    rect.w = tw;
 535    rect.h = th;
 536    ni     = TESTRENDER_SCREEN_W - tw;
 537    nj     = TESTRENDER_SCREEN_H - th;
 538
 539    /* Test blitting with alpha mod. */
 540    checkFailCount1 = 0;
 541    checkFailCount2 = 0;
 542    for (j=0; j <= nj; j+=4) {
 543       for (i=0; i <= ni; i+=4) {
 544          /* Set alpha mod. */
 545          ret = SDL_SetTextureAlphaMod( tface, (255/ni)*i );
 546          if (ret != 0) checkFailCount1++;
 547
 548          /* Blitting. */
 549          rect.x = i;
 550          rect.y = j;
 551          ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
 552          if (ret != 0) checkFailCount2++;
 553       }
 554    }
 555    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount1);
 556    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
 557
 558    /* Make current */
 559    SDL_RenderPresent(renderer);
 560
 561    /* See if it's the same. */
 562    referenceSurface = SDLTest_ImageBlitAlpha();
 563    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 564
 565    /* Clean up. */
 566    SDL_DestroyTexture( tface );
 567    SDL_FreeSurface(referenceSurface);
 568    referenceSurface = NULL;
 569
 570    return TEST_COMPLETED;
 571 }
 572
 573 /* Helper functions */
 574
 575 /**
 576  * @brief Tests a blend mode.
 577  *
 578  * \sa
 579  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureBlendMode
 580  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
 581  */
 582 static void
 583 _testBlitBlendMode( SDL_Texture * tface, int mode )
 584 {
 585    int ret;
 586    Uint32 tformat;
 587    int taccess, tw, th;
 588    int i, j, ni, nj;
 589    SDL_Rect rect;
 590    int checkFailCount1;
 591    int checkFailCount2;
 592
 593    /* Clear surface. */
 594    _clearScreen();
 595
 596    /* Constant values. */
 597    ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
 598    SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
 599    rect.w = tw;
 600    rect.h = th;
 601    ni     = TESTRENDER_SCREEN_W - tw;
 602    nj     = TESTRENDER_SCREEN_H - th;
 603
 604    /* Test blend mode. */
 605    checkFailCount1 = 0;
 606    checkFailCount2 = 0;
 607    for (j=0; j <= nj; j+=4) {
 608       for (i=0; i <= ni; i+=4) {
 609          /* Set blend mode. */
 610          ret = SDL_SetTextureBlendMode( tface, (SDL_BlendMode)mode );
 611          if (ret != 0) checkFailCount1++;
 612
 613          /* Blitting. */
 614          rect.x = i;
 615          rect.y = j;
 616          ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
 617          if (ret != 0) checkFailCount2++;
 618       }
 619    }
 620    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureBlendMode, expected: 0, got: %i", checkFailCount1);
 621    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
 622 }
 623
 624
 625 /**
 626  * @brief Tests some more blitting routines.
 627  *
 628  * \sa
 629  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
 630  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
 631  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureBlendMode
 632  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
 633  */
 634 int
 635 render_testBlitBlend (void *arg)
 636 {
 637    int ret;
 638    SDL_Rect rect;
 639    SDL_Texture *tface;
 640    SDL_Surface *referenceSurface = NULL;
 641    Uint32 tformat;
 642    int taccess, tw, th;
 643    int i, j, ni, nj;
 644    int mode;
 645    int checkFailCount1;
 646    int checkFailCount2;
 647    int checkFailCount3;
 648    int checkFailCount4;
 649
 650    SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
 651    SDLTest_AssertCheck(_hasTexColor(), "_hasTexColor");
 652    SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
 653
 654    /* Create face surface. */
 655    tface = _loadTestFace();
 656    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
 657    if (tface == NULL) {
 658        return TEST_ABORTED;
 659    }
 660
 661    /* Constant values. */
 662    ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
 663    SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
 664    rect.w = tw;
 665    rect.h = th;
 666    ni = TESTRENDER_SCREEN_W - tw;
 667    nj = TESTRENDER_SCREEN_H - th;
 668
 669    /* Set alpha mod. */
 670    ret = SDL_SetTextureAlphaMod( tface, 100 );
 671    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetTextureAlphaMod, expected: 0, got: %i", ret);
 672
 673    /* Test None. */
 674    _testBlitBlendMode( tface, SDL_BLENDMODE_NONE );
 675    referenceSurface = SDLTest_ImageBlitBlendNone();
 676
 677    /* Make current and compare */
 678    SDL_RenderPresent(renderer);
 679    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
 680    SDL_FreeSurface(referenceSurface);
 681    referenceSurface = NULL;
 682
 683    /* Test Blend. */
 684    _testBlitBlendMode( tface, SDL_BLENDMODE_BLEND );
 685    referenceSurface = SDLTest_ImageBlitBlend();
 686
 687    /* Make current and compare */
 688    SDL_RenderPresent(renderer);
 689    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 690    SDL_FreeSurface(referenceSurface);
 691    referenceSurface = NULL;
 692
 693    /* Test Add. */
 694    _testBlitBlendMode( tface, SDL_BLENDMODE_ADD );
 695    referenceSurface = SDLTest_ImageBlitBlendAdd();
 696
 697    /* Make current and compare */
 698    SDL_RenderPresent(renderer);
 699    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 700    SDL_FreeSurface(referenceSurface);
 701    referenceSurface = NULL;
 702
 703    /* Test Mod. */
 704    _testBlitBlendMode( tface, SDL_BLENDMODE_MOD);
 705    referenceSurface = SDLTest_ImageBlitBlendMod();
 706
 707    /* Make current and compare */
 708    SDL_RenderPresent(renderer);
 709    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
 710    SDL_FreeSurface(referenceSurface);
 711    referenceSurface = NULL;
 712
 713    /* Clear surface. */
 714    _clearScreen();
 715
 716    /* Loop blit. */
 717    checkFailCount1 = 0;
 718    checkFailCount2 = 0;
 719    checkFailCount3 = 0;
 720    checkFailCount4 = 0;
 721    for (j=0; j <= nj; j+=4) {
 722       for (i=0; i <= ni; i+=4) {
 723
 724          /* Set color mod. */
 725          ret = SDL_SetTextureColorMod( tface, (255/nj)*j, (255/ni)*i, (255/nj)*j );
 726          if (ret != 0) checkFailCount1++;
 727
 728          /* Set alpha mod. */
 729          ret = SDL_SetTextureAlphaMod( tface, (100/ni)*i );
 730          if (ret != 0) checkFailCount2++;
 731
 732          /* Crazy blending mode magic. */
 733          mode = (i/4*j/4) % 4;
 734          if (mode==0) mode = SDL_BLENDMODE_NONE;
 735          else if (mode==1) mode = SDL_BLENDMODE_BLEND;
 736          else if (mode==2) mode = SDL_BLENDMODE_ADD;
 737          else if (mode==3) mode = SDL_BLENDMODE_MOD;
 738          ret = SDL_SetTextureBlendMode( tface, (SDL_BlendMode)mode );
 739          if (ret != 0) checkFailCount3++;
 740
 741          /* Blitting. */
 742          rect.x = i;
 743          rect.y = j;
 744          ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
 745          if (ret != 0) checkFailCount4++;
 746       }
 747    }
 748    SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1);
 749    SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount2);
 750    SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetTextureBlendMode, expected: 0, got: %i", checkFailCount3);
 751    SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount4);
 752
 753    /* Clean up. */
 754    SDL_DestroyTexture( tface );
 755
 756    /* Make current */
 757    SDL_RenderPresent(renderer);
 758
 759    /* Check to see if final image matches. */
 760    referenceSurface = SDLTest_ImageBlitBlendAll();
 761    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
 762    SDL_FreeSurface(referenceSurface);
 763    referenceSurface = NULL;
 764
 765    return TEST_COMPLETED;
 766 }
 767
 768
 769 /**
 770  * @brief Checks to see if functionality is supported. Helper function.
 771  */
 772 static int
 773 _isSupported( int code )
 774 {
 775    return (code == 0);
 776 }
 777
 778 /**
 779  * @brief Test to see if we can vary the draw color. Helper function.
 780  *
 781  * \sa
 782  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
 783  * http://wiki.libsdl.org/moin.cgi/SDL_GetRenderDrawColor
 784  */
 785 static int
 786 _hasDrawColor (void)
 787 {
 788    int ret, fail;
 789    Uint8 r, g, b, a;
 790
 791    fail = 0;
 792
 793    /* Set color. */
 794    ret = SDL_SetRenderDrawColor(renderer, 100, 100, 100, 100 );
 795    if (!_isSupported(ret))
 796       fail = 1;
 797    ret = SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a );
 798    if (!_isSupported(ret))
 799       fail = 1;
 800
 801    /* Restore natural. */
 802    ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE );
 803    if (!_isSupported(ret))
 804       fail = 1;
 805
 806    /* Something failed, consider not available. */
 807    if (fail)
 808       return 0;
 809
 810    /* Not set properly, consider failed. */
 811    else if ((r != 100) || (g != 100) || (b != 100) || (a != 100))
 812       return 0;
 813    return 1;
 814 }
 815
 816 /**
 817  * @brief Test to see if we can vary the blend mode. Helper function.
 818  *
 819  * \sa
 820  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
 821  * http://wiki.libsdl.org/moin.cgi/SDL_GetRenderDrawBlendMode
 822  */
 823 static int
 824 _hasBlendModes (void)
 825 {
 826    int fail;
 827    int ret;
 828    SDL_BlendMode mode;
 829
 830    fail = 0;
 831
 832    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND );
 833    if (!_isSupported(ret))
 834       fail = 1;
 835    ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
 836    if (!_isSupported(ret))
 837       fail = 1;
 838    ret = (mode != SDL_BLENDMODE_BLEND);
 839    if (!_isSupported(ret))
 840       fail = 1;
 841    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD );
 842    if (!_isSupported(ret))
 843       fail = 1;
 844    ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
 845    if (!_isSupported(ret))
 846       fail = 1;
 847    ret = (mode != SDL_BLENDMODE_ADD);
 848    if (!_isSupported(ret))
 849       fail = 1;
 850    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_MOD );
 851    if (!_isSupported(ret))
 852       fail = 1;
 853    ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
 854    if (!_isSupported(ret))
 855       fail = 1;
 856    ret = (mode != SDL_BLENDMODE_MOD);
 857    if (!_isSupported(ret))
 858       fail = 1;
 859    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
 860    if (!_isSupported(ret))
 861       fail = 1;
 862    ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
 863    if (!_isSupported(ret))
 864       fail = 1;
 865    ret = (mode != SDL_BLENDMODE_NONE);
 866    if (!_isSupported(ret))
 867       fail = 1;
 868
 869    return !fail;
 870 }
 871
 872
 873 /**
 874  * @brief Loads the test image 'Face' as texture. Helper function.
 875  *
 876  * \sa
 877  * http://wiki.libsdl.org/moin.cgi/SDL_CreateTextureFromSurface
 878  */
 879 static SDL_Texture *
 880 _loadTestFace(void)
 881 {
 882    SDL_Surface *face;
 883    SDL_Texture *tface;
 884
 885    face = SDLTest_ImageFace();
 886    if (face == NULL) {
 887       return NULL;
 888    }
 889
 890    tface = SDL_CreateTextureFromSurface(renderer, face);
 891    if (tface == NULL) {
 892        SDLTest_LogError("SDL_CreateTextureFromSurface() failed with error: %s", SDL_GetError());
 893    }
 894
 895    SDL_FreeSurface(face);
 896
 897    return tface;
 898 }
 899
 900
 901 /**
 902  * @brief Test to see if can set texture color mode. Helper function.
 903  *
 904  * \sa
 905  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureColorMod
 906  * http://wiki.libsdl.org/moin.cgi/SDL_GetTextureColorMod
 907  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
 908  */
 909 static int
 910 _hasTexColor (void)
 911 {
 912    int fail;
 913    int ret;
 914    SDL_Texture *tface;
 915    Uint8 r, g, b;
 916
 917    /* Get test face. */
 918    tface = _loadTestFace();
 919    if (tface == NULL)
 920       return 0;
 921
 922    /* See if supported. */
 923    fail = 0;
 924    ret = SDL_SetTextureColorMod( tface, 100, 100, 100 );
 925    if (!_isSupported(ret))
 926       fail = 1;
 927    ret = SDL_GetTextureColorMod( tface, &r, &g, &b );
 928    if (!_isSupported(ret))
 929       fail = 1;
 930
 931    /* Clean up. */
 932    SDL_DestroyTexture( tface );
 933
 934    if (fail)
 935       return 0;
 936    else if ((r != 100) || (g != 100) || (b != 100))
 937       return 0;
 938    return 1;
 939 }
 940
 941 /**
 942  * @brief Test to see if we can vary the alpha of the texture. Helper function.
 943  *
 944  * \sa
 945  *  http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
 946  *  http://wiki.libsdl.org/moin.cgi/SDL_GetTextureAlphaMod
 947  *  http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
 948  */
 949 static int
 950 _hasTexAlpha(void)
 951 {
 952    int fail;
 953    int ret;
 954    SDL_Texture *tface;
 955    Uint8 a;
 956
 957    /* Get test face. */
 958    tface = _loadTestFace();
 959    if (tface == NULL)
 960       return 0;
 961
 962    /* See if supported. */
 963    fail = 0;
 964    ret = SDL_SetTextureAlphaMod( tface, 100 );
 965    if (!_isSupported(ret))
 966       fail = 1;
 967    ret = SDL_GetTextureAlphaMod( tface, &a );
 968    if (!_isSupported(ret))
 969       fail = 1;
 970
 971    /* Clean up. */
 972    SDL_DestroyTexture( tface );
 973
 974    if (fail)
 975       return 0;
 976    else if (a != 100)
 977       return 0;
 978    return 1;
 979 }
 980
 981 /**
 982  * @brief Compares screen pixels with image pixels. Helper function.
 983  *
 984  * @param s Image to compare against.
 985  *
 986  * \sa
 987  * http://wiki.libsdl.org/moin.cgi/SDL_RenderReadPixels
 988  * http://wiki.libsdl.org/moin.cgi/SDL_CreateRGBSurfaceFrom
 989  * http://wiki.libsdl.org/moin.cgi/SDL_FreeSurface
 990  */
 991 static void
 992 _compare(SDL_Surface *referenceSurface, int allowable_error)
 993 {
 994    int result;
 995    SDL_Rect rect;
 996    Uint8 *pixels;
 997    SDL_Surface *testSurface;
 998
 999    /* Read pixels. */
1000    pixels = (Uint8 *)SDL_malloc(4*TESTRENDER_SCREEN_W*TESTRENDER_SCREEN_H);
1001    SDLTest_AssertCheck(pixels != NULL, "Validate allocated temp pixel buffer");
1002    if (pixels == NULL) return;
1003
1004    /* Explicitly specify the rect in case the window isn't the expected size... */
1005    rect.x = 0;
1006    rect.y = 0;
1007    rect.w = TESTRENDER_SCREEN_W;
1008    rect.h = TESTRENDER_SCREEN_H;
1009    result = SDL_RenderReadPixels(renderer, &rect, RENDER_COMPARE_FORMAT, pixels, 80*4 );
1010    SDLTest_AssertCheck(result == 0, "Validate result from SDL_RenderReadPixels, expected: 0, got: %i", result);
1011
1012    /* Create surface. */
1013    testSurface = SDL_CreateRGBSurfaceFrom(pixels, TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, 32, TESTRENDER_SCREEN_W*4,
1014                                        RENDER_COMPARE_RMASK, RENDER_COMPARE_GMASK, RENDER_COMPARE_BMASK, RENDER_COMPARE_AMASK);
1015    SDLTest_AssertCheck(testSurface != NULL, "Verify result from SDL_CreateRGBSurfaceFrom is not NULL");
1016
1017    /* Compare surface. */
1018    result = SDLTest_CompareSurfaces( testSurface, referenceSurface, allowable_error );
1019    SDLTest_AssertCheck(result == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", result);
1020
1021    /* Clean up. */
1022    SDL_free(pixels);
1023    SDL_FreeSurface(testSurface);
1024 }
1025
1026 /**
1027  * @brief Clears the screen. Helper function.
1028  *
1029  * \sa
1030  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawColor
1031  * http://wiki.libsdl.org/moin.cgi/SDL_RenderClear
1032  * http://wiki.libsdl.org/moin.cgi/SDL_RenderPresent
1033  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
1034  */
1035 static int
1036 _clearScreen(void)
1037 {
1038    int ret;
1039
1040    /* Set color. */
1041    ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE );
1042    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
1043
1044    /* Clear screen. */
1045    ret = SDL_RenderClear(renderer);
1046    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderClear, expected: 0, got: %i", ret);
1047
1048    /* Make current */
1049    SDL_RenderPresent(renderer);
1050
1051    /* Set defaults. */
1052    ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
1053    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
1054
1055    ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE );
1056    SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
1057
1058    return 0;
1059 }
1060
1061 /* ================= Test References ================== */
1062
1063 /* Render test cases */
1064
1065 static const SDLTest_TestCaseReference renderTest1 =
1066         { (SDLTest_TestCaseFp)render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED };
1067
1068 static const SDLTest_TestCaseReference renderTest2 =
1069         { (SDLTest_TestCaseFp)render_testPrimitives, "render_testPrimitives", "Tests rendering primitives", TEST_ENABLED };
1070
1071 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
1072 static const SDLTest_TestCaseReference renderTest3 =
1073         { (SDLTest_TestCaseFp)render_testPrimitivesBlend, "render_testPrimitivesBlend", "Tests rendering primitives with blending", TEST_DISABLED };
1074
1075 static const SDLTest_TestCaseReference renderTest4 =
1076         { (SDLTest_TestCaseFp)render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED };
1077
1078 static const SDLTest_TestCaseReference renderTest5 =
1079         { (SDLTest_TestCaseFp)render_testBlitColor, "render_testBlitColor", "Tests blitting with color", TEST_ENABLED };
1080
1081 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
1082 static const SDLTest_TestCaseReference renderTest6 =
1083         { (SDLTest_TestCaseFp)render_testBlitAlpha, "render_testBlitAlpha", "Tests blitting with alpha", TEST_DISABLED };
1084
1085 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
1086 static const SDLTest_TestCaseReference renderTest7 =
1087         {  (SDLTest_TestCaseFp)render_testBlitBlend, "render_testBlitBlend", "Tests blitting with blending", TEST_DISABLED };
1088
1089 /* Sequence of Render test cases */
1090 static const SDLTest_TestCaseReference *renderTests[] =  {
1091     &renderTest1, &renderTest2, &renderTest3, &renderTest4, &renderTest5, &renderTest6, &renderTest7, NULL
1092 };
1093
1094 /* Render test suite (global) */
1095 SDLTest_TestSuiteReference renderTestSuite = {
1096     "Render",
1097     InitCreateRenderer,
1098     renderTests,
1099     CleanupDestroyRenderer
1100 };