test/testautomation_render.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 07 Dec 2017 16:08:09 -0800
changeset 11730 ac6c607e065c
parent 9254 6c469ea796e4
permissions -rw-r--r--
Enable building the Metal renderer by default, and weak link the Metal framework so the SDL library is safe to use on older Macs
Also generate iOS versions of the Metal shaders
     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, 0);
    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 static const SDLTest_TestCaseReference renderTest1 =
  1065         { (SDLTest_TestCaseFp)render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED };
  1066 
  1067 static const SDLTest_TestCaseReference renderTest2 =
  1068         { (SDLTest_TestCaseFp)render_testPrimitives, "render_testPrimitives", "Tests rendering primitives", TEST_ENABLED };
  1069 
  1070 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
  1071 static const SDLTest_TestCaseReference renderTest3 =
  1072         { (SDLTest_TestCaseFp)render_testPrimitivesBlend, "render_testPrimitivesBlend", "Tests rendering primitives with blending", TEST_DISABLED };
  1073 
  1074 static const SDLTest_TestCaseReference renderTest4 =
  1075         { (SDLTest_TestCaseFp)render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED };
  1076 
  1077 static const SDLTest_TestCaseReference renderTest5 =
  1078         { (SDLTest_TestCaseFp)render_testBlitColor, "render_testBlitColor", "Tests blitting with color", TEST_ENABLED };
  1079 
  1080 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
  1081 static const SDLTest_TestCaseReference renderTest6 =
  1082         { (SDLTest_TestCaseFp)render_testBlitAlpha, "render_testBlitAlpha", "Tests blitting with alpha", TEST_DISABLED };
  1083 
  1084 /* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
  1085 static const SDLTest_TestCaseReference renderTest7 =
  1086         {  (SDLTest_TestCaseFp)render_testBlitBlend, "render_testBlitBlend", "Tests blitting with blending", TEST_DISABLED };
  1087 
  1088 /* Sequence of Render test cases */
  1089 static const SDLTest_TestCaseReference *renderTests[] =  {
  1090     &renderTest1, &renderTest2, &renderTest3, &renderTest4, &renderTest5, &renderTest6, &renderTest7, NULL
  1091 };
  1092 
  1093 /* Render test suite (global) */
  1094 SDLTest_TestSuiteReference renderTestSuite = {
  1095     "Render",
  1096     InitCreateRenderer,
  1097     renderTests,
  1098     CleanupDestroyRenderer
  1099 };