Ported surface tests.

test/test-automation/Makefile.am

 ACLOCAL_AMFLAGS = -I acinclude -I build-scripts
 
-SUBDIRS = testdummy testrect testplatform testaudio
+SUBDIRS = testdummy testrect testplatform testaudio testsurface
 
 bin_PROGRAMS = runner
 runner_SOURCES = runner.c SDL_test.c logger.c xml_logger.c plain_logger.c xml.c logger_helpers.c

test/test-automation/SDL_test.c

@@ -74,7 +74,7 @@ AssertEquals(Uint32 expected, Uint32 actual, char* message, ...)
       _testReturnValue = 1;
       _testAssertsFailed++;
    } else {
-	   AssertWithValues("AssertEquals", 1, "AssertEquals passed",
+	   AssertWithValues("AssertEquals", 1, buf,
     		  actual, expected, time(0));
 
       _testAssertsPassed++;
@@ -92,15 +92,17 @@ AssertTrue(int condition, char *message, ...)
       SDL_vsnprintf( buf, sizeof(buf), message, args );
       va_end( args );
 
-      //printf("AssertTrue failed: %s\n", buf);
       Assert("AssertTrue", 0, buf, time(0));
 
       _testReturnValue = 1;
       _testAssertsFailed++;
    } else {
-     //printf("AssertTrue passed\n");
-	 Assert("AssertTrue", 1, "AssertTrue passed", time(0));
-     _testAssertsPassed++;
+		va_start( args, message );
+		SDL_vsnprintf( buf, sizeof(buf), message, args );
+		va_end( args );
+
+		Assert("AssertTrue", 1, buf, time(0));
+		_testAssertsPassed++;
    }
 }
 

test/test-automation/build-scripts/install-tests.sh

@@ -16,7 +16,7 @@ elif [[ $PLATFORM ==  "Darwin" ]]; then
 fi
 
 # TODO: put the test in an array
-for suite in "testdummy" "testplatform" "testrect" "testaudio"
+for suite in "testdummy" "testplatform" "testrect" "testaudio" "testsurface"
 do
 	cp -f "$suite/.libs/lib$suite.$EXT" $DIRECTORY
 done

test/test-automation/common/common.c

@@ -7,12 +7,9 @@
  */
 
 
-#include "SDL.h"
-#include "../SDL_at.h"
 
 #include "common.h"
 
-
 /**
  * @brief Compares a surface and a surface image for equality.
  */

test/test-automation/common/common.h

@@ -10,6 +10,7 @@
 #ifndef COMMON_H
 #  define COMMON_H
 
+#include "SDL/SDL.h"
 
 #  define FORMAT  SDL_PIXELFORMAT_ARGB8888
 #  define AMASK   0xff000000 /**< Alpha bit mask. */

test/test-automation/common/img_blit.c

 /* GIMP RGB C-Source image dump (blit.c) */
 
+#include "common.h"
+
 static const SurfaceImage_t img_blit = {
   80, 60, 3,
   "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

test/test-automation/common/img_blitblend.c

 /* GIMP RGB C-Source image dump (alpha.c) */
+#include "common.h"
 
 static const SurfaceImage_t img_blendAdd = {
   80, 60, 3,

test/test-automation/common/img_face.c

 /* GIMP RGBA C-Source image dump (face.c) */
+#include "common.h"
 
 static const SurfaceImage_t img_face = {
   32, 32, 4,

test/test-automation/common/img_primitives.c

 /* GIMP RGB C-Source image dump (primitives.c) */
+#include "common.h"
 
 static const SurfaceImage_t img_primitives = {
   80, 60, 3,

test/test-automation/common/img_primitivesblend.c

 /* GIMP RGB C-Source image dump (alpha.c) */
+#include "common.h"
 
 static const SurfaceImage_t img_blend = {
   80, 60, 3,

test/test-automation/configure.ac

@@ -36,7 +36,8 @@ AC_CONFIG_FILES([Makefile
 				 testdummy/Makefile 
 				 testrect/Makefile
 				 testplatform/Makefile
-				 testaudio/Makefile])
+				 testaudio/Makefile
+				 testsurface/Makefile])
 AC_OUTPUT
 
 echo ""

test/test-automation/plain_logger.c

@@ -104,7 +104,7 @@ PlainAssert(const char *assertName, int assertResult, const char *assertMessage,
 		time_t eventTime)
 {
 	const char *result = (assertResult) ? "passed" : "failed";
-	Output(indentLevel, "%s: %s", assertName, assertMessage);
+	Output(indentLevel, "%s: %s; %s", assertName, result, assertMessage);
 }
 
 void
@@ -112,8 +112,8 @@ PlainAssertWithValues(const char *assertName, int assertResult, const char *asse
 		int actualValue, int expected, time_t eventTime)
 {
 	const char *result = (assertResult) ? "passed" : "failed";
-	Output(indentLevel, "%s %d (expected %d, actualValue &d): %s",
-			assertName, assertResult, expected, actualValue, assertMessage);
+	Output(indentLevel, "%s %s (expected %d, actualValue &d): %s",
+			assertName, result, expected, actualValue, assertMessage);
 }
 
 void

test/test-automation/testsurface/Makefile.am

+lib_LTLIBRARIES = libtestsurface.la
+libtestsurface_la_SOURCES = testsurface.c ../SDL_test.c ../logger.c ../logger_helpers.c ../plain_logger.c ../xml_logger.c ../xml.c \ 
+	../common/common.c ../common/img_blit.c ../common/img_blitblend.c ../common/img_face.c ../common/img_primitives.c ../common/img_primitivesblend.c
+libtestsurface_la_CLAGS = -fPIC -g
+libtestsurface_la_LDFLAGS = `sdl-config --libs`

test/test-automation/testsurface/testsurface.c

+/**
+ * Original code: automated SDL surface test written by Edgar Simo "bobbens"
+ */
+
+#ifndef _TEST_C
+#define _TEST_C
+#include <stdio.h>
+
+#include <SDL/SDL.h>
+
+#include "../SDL_test.h"
+
+#include "../common/common.h"
+#include "../common/images.h"
+
+
+/* Test case references */
+static const TestCaseReference test1 =
+		(TestCaseReference){ "surface_testLoad", "Tests sprite loading.", TEST_ENABLED, 0, 0};
+
+static const TestCaseReference test2 =
+		(TestCaseReference){ "surface_testBlit", "Tests some blitting routines.", TEST_ENABLED, 0, 0};
+
+static const TestCaseReference test3 =
+		(TestCaseReference){ "surface_testBlitBlend", "Tests some more blitting routines.", TEST_ENABLED, 0, 0};
+
+
+/* Test suite */
+extern const TestCaseReference *testSuite[] =  {
+	&test1, &test2, &test3, NULL
+};
+
+
+TestCaseReference **QueryTestSuite() {
+	return (TestCaseReference **)testSuite;
+}
+
+/* Test helpers */
+
+/*!
+ * Creates test surface
+ */
+SDL_Surface *
+CreateTestSurface() {
+	SDL_Surface *testsur;
+
+	/* Create the test surface. */
+	testsur = SDL_CreateRGBSurface( 0, 80, 60, 32,
+		 RMASK, GMASK, BMASK, AMASK );
+
+	AssertTrue(testsur != NULL, "SDL_CreateRGBSurface");
+
+	return testsur;
+}
+
+int testBlitBlendMode(SDL_Surface *testsur, SDL_Surface *face, int mode)
+{
+	int ret;
+	int i, j, ni, nj;
+	SDL_Rect rect;
+
+	/* Clear surface. */
+	ret = SDL_FillRect( testsur, NULL,
+		 SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+	if(ret == 0)
+	  return 1;
+
+	/* Steps to take. */
+	ni     = testsur->w - face->w;
+	nj     = testsur->h - face->h;
+
+	/* Constant values. */
+	rect.w = face->w;
+	rect.h = face->h;
+
+	/* Test blend mode. */
+	for (j=0; j <= nj; j+=4) {
+	  for (i=0; i <= ni; i+=4) {
+		 /* Set blend mode. */
+		 ret = SDL_SetSurfaceBlendMode( face, mode );
+		 if (ret == 0)
+			return 1;
+
+		 /* Blitting. */
+		 rect.x = i;
+		 rect.y = j;
+		 ret = SDL_BlitSurface( face, NULL, testsur, &rect );
+		 if(ret == 0)
+			return 1;
+	  }
+	}
+
+	   return 0;
+}
+
+/* Test case functions */
+/**
+ * @brief Tests sprite loading.
+ */
+void surface_testLoad(void *arg)
+{
+	int ret;
+    SDL_Surface *face, *rface;
+
+	ret = SDL_Init(SDL_INIT_VIDEO);
+	AssertTrue(ret == 0, "SDL_Init(SDL_INIT_VIDEO)");
+
+	SDL_Surface *testsur = CreateTestSurface();
+
+   /* Clear surface. */
+   ret = SDL_FillRect( testsur, NULL,
+         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+	AssertTrue(ret == 0,  "SDL_FillRect");
+
+   /* Create the blit surface. */
+#ifdef __APPLE__
+	face = SDL_LoadBMP("icon.bmp");
+#else
+	face = SDL_LoadBMP("../icon.bmp");
+#endif
+
+	AssertTrue(face != NULL, "SDL_CreateLoadBmp");
+
+   /* Set transparent pixel as the pixel at (0,0) */
+   if (face->format->palette) {
+      ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
+      AssertTrue(ret == 0, "SDL_SetColorKey");
+   }
+
+   /* Convert to 32 bit to compare. */
+   rface = SDL_ConvertSurface( face, testsur->format, 0 );
+   AssertTrue(rface != NULL, "SDL_ConvertSurface");
+
+   /* See if it's the same. */
+   AssertTrue(surface_compare( rface, &img_face, 0 ) == 0,
+		   "Primitives output not the same.");
+
+   /* Clean up. */
+   SDL_FreeSurface( rface );
+   SDL_FreeSurface( face );
+
+   SDL_FreeSurface( testsur );
+
+   SDL_Quit();
+}
+
+
+/**
+ * @brief Tests some blitting routines.
+ */
+void surface_testBlit(void *arg)
+{
+   int ret;
+   SDL_Rect rect;
+   SDL_Surface *face;
+   int i, j, ni, nj;
+
+	ret = SDL_Init(SDL_INIT_VIDEO);
+	AssertTrue(ret == 0, "SDL_Init(SDL_INIT_VIDEO)");
+
+   SDL_Surface *testsur = CreateTestSurface();
+
+   /* Clear surface. */
+   ret = SDL_FillRect( testsur, NULL,
+         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+
+   AssertTrue(ret == 0, "SDL_FillRect");
+
+   /* Create face surface. */
+   face = SDL_CreateRGBSurfaceFrom( (void*)img_face.pixel_data,
+         img_face.width, img_face.height, 32, img_face.width*4,
+#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+         0xff000000, /* Red bit mask. */
+         0x00ff0000, /* Green bit mask. */
+         0x0000ff00, /* Blue bit mask. */
+         0x000000ff /* Alpha bit mask. */
+#else
+         0x000000ff, /* Red bit mask. */
+         0x0000ff00, /* Green bit mask. */
+         0x00ff0000, /* Blue bit mask. */
+         0xff000000 /* Alpha bit mask. */
+#endif
+         );
+   AssertTrue(face != NULL, "SDL_CreateRGBSurfaceFrom");
+
+   /* Constant values. */
+   rect.w = face->w;
+   rect.h = face->h;
+   ni     = testsur->w - face->w;
+   nj     = testsur->h - face->h;
+
+   /* Loop blit. */
+   for (j=0; j <= nj; j+=4) {
+      for (i=0; i <= ni; i+=4) {
+         /* Blitting. */
+         rect.x = i;
+         rect.y = j;
+         ret = SDL_BlitSurface( face, NULL, testsur, &rect );
+
+         AssertTrue(ret == 0, "SDL_BlitSurface");
+      }
+   }
+
+   /* See if it's the same. */
+   AssertTrue(surface_compare( testsur, &img_blit, 0 ) == 0,
+		   "Blitting output not the same (normal blit).");
+
+   /* Clear surface. */
+   ret = SDL_FillRect( testsur, NULL,
+         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+   AssertTrue(ret == 0, "SDL_FillRect");
+
+   /* Test blitting with colour mod. */
+   for (j=0; j <= nj; j+=4) {
+      for (i=0; i <= ni; i+=4) {
+         /* Set colour mod. */
+         ret = SDL_SetSurfaceColorMod( face, (255/nj)*j, (255/ni)*i, (255/nj)*j );
+         AssertTrue(ret == 0, "SDL_SetSurfaceColorMod");
+
+         /* Blitting. */
+         rect.x = i;
+         rect.y = j;
+         ret = SDL_BlitSurface( face, NULL, testsur, &rect );
+
+         AssertTrue(ret == 0, "SDL_BlitSurface");
+      }
+   }
+
+   /* See if it's the same. */
+   AssertTrue(surface_compare( testsur, &img_blitColour, 0 ) == 0,
+		   "Blitting output not the same (using SDL_SetSurfaceColorMod).");
+
+   /* Clear surface. */
+   ret = SDL_FillRect( testsur, NULL,
+         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+   AssertTrue(ret == 0, "SDL_FillRect");
+
+   /* Restore colour. */
+   ret = SDL_SetSurfaceColorMod( face, 255, 255, 255 );
+   AssertTrue(ret == 0, "SDL_SetSurfaceColorMod");
+
+   /* Test blitting with colour mod. */
+   for (j=0; j <= nj; j+=4) {
+      for (i=0; i <= ni; i+=4) {
+         /* Set alpha mod. */
+         ret = SDL_SetSurfaceAlphaMod( face, (255/ni)*i );
+         AssertTrue(ret == 0, "SDL_SetSurfaceAlphaMod");
+
+         /* Blitting. */
+         rect.x = i;
+         rect.y = j;
+         ret = SDL_BlitSurface( face, NULL, testsur, &rect );
+         AssertTrue(ret == 0, "SDL_BlitSurface");
+      }
+   }
+
+   /* See if it's the same. */
+   AssertTrue(surface_compare( testsur, &img_blitAlpha, 0 ) == 0,
+		   "Blitting output not the same (using SDL_SetSurfaceAlphaMod).");
+
+   /* Clean up. */
+   SDL_FreeSurface( face );
+   SDL_FreeSurface( testsur );
+
+   SDL_Quit();
+}
+
+
+/**
+ * @brief Tests a blend mode.
+ */
+
+
+
+/**
+ * @brief Tests some more blitting routines.
+ */
+void surface_testBlitBlend(void *arg)
+{
+   int ret;
+   SDL_Rect rect;
+   SDL_Surface *face;
+   int i, j, ni, nj;
+   int mode;
+
+	ret = SDL_Init(SDL_INIT_VIDEO);
+	AssertTrue(ret == 0, "SDL_Init(SDL_INIT_VIDEO)");
+
+   SDL_Surface *testsur = CreateTestSurface();
+
+   /* Clear surface. */
+   ret = SDL_FillRect( testsur, NULL,
+         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+
+   AssertTrue(ret == 0, "SDL_FillRect");
+
+   /* Create the blit surface. */
+   face = SDL_CreateRGBSurfaceFrom( (void*)img_face.pixel_data,
+         img_face.width, img_face.height, 32, img_face.width*4,
+#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+         0xff000000, /* Red bit mask. */
+         0x00ff0000, /* Green bit mask. */
+         0x0000ff00, /* Blue bit mask. */
+         0x000000ff /* Alpha bit mask. */
+#else
+         0x000000ff, /* Red bit mask. */
+         0x0000ff00, /* Green bit mask. */
+         0x00ff0000, /* Blue bit mask. */
+         0xff000000 /* Alpha bit mask. */
+#endif
+         );
+   AssertTrue(face != NULL, "SDL_CreateRGBSurfaceFrom");
+
+   /* Set alpha mod. */
+   ret = SDL_SetSurfaceAlphaMod( face, 100 );
+   AssertTrue(ret == 0, "SDL_SetSurfaceAlphaMod");
+
+   /* Steps to take. */
+   ni     = testsur->w - face->w;
+   nj     = testsur->h - face->h;
+
+   /* Constant values. */
+   rect.w = face->w;
+   rect.h = face->h;
+
+   /* Test None. */
+   if (testBlitBlendMode( testsur, face, SDL_BLENDMODE_NONE ))
+      return;
+   AssertTrue(surface_compare( testsur, &img_blendNone, 0 ) == 0,
+		   "Blitting blending output not the same (using SDL_BLENDMODE_NONE).");
+
+
+   /* Test Blend. */
+   if (testBlitBlendMode( testsur, face, SDL_BLENDMODE_BLEND ))
+      return;
+   AssertTrue(surface_compare( testsur, &img_blendBlend, 0 ) == 0,
+		   "Blitting blending output not the same (using SDL_BLENDMODE_BLEND).");
+
+   /* Test Add. */
+   if (testBlitBlendMode( testsur, face, SDL_BLENDMODE_ADD ))
+      return;
+   AssertTrue(surface_compare( testsur, &img_blendAdd, 0 ) == 0,
+		      "Blitting blending output not the same (using SDL_BLENDMODE_ADD).");
+
+   /* Test Mod. */
+   if (testBlitBlendMode( testsur, face, SDL_BLENDMODE_MOD ))
+      return;
+   AssertTrue(surface_compare( testsur, &img_blendMod, 0 ) == 0,
+		      "Blitting blending output not the same (using SDL_BLENDMODE_MOD).");
+
+   /* Clear surface. */
+   ret = SDL_FillRect( testsur, NULL,
+         SDL_MapRGB( testsur->format, 0, 0, 0 ) );
+
+   AssertTrue(ret == 0, "SDL_FillRect");
+
+   /* Loop blit. */
+   for (j=0; j <= nj; j+=4) {
+      for (i=0; i <= ni; i+=4) {
+
+         /* Set colour mod. */
+         ret = SDL_SetSurfaceColorMod( face, (255/nj)*j, (255/ni)*i, (255/nj)*j );
+         AssertTrue(ret == 0, "SDL_SetSurfaceColorMod");
+
+         /* Set alpha mod. */
+         ret = SDL_SetSurfaceAlphaMod( face, (100/ni)*i );
+         AssertTrue(ret == 0, "SDL_SetSurfaceAlphaMod");
+
+         /* Crazy blending mode magic. */
+         mode = (i/4*j/4) % 4;
+         if (mode==0) mode = SDL_BLENDMODE_NONE;
+         else if (mode==1) mode = SDL_BLENDMODE_BLEND;
+         else if (mode==2) mode = SDL_BLENDMODE_ADD;
+         else if (mode==3) mode = SDL_BLENDMODE_MOD;
+         ret = SDL_SetSurfaceBlendMode( face, mode );
+
+         AssertTrue(ret == 0, "SDL_SetSurfaceBlendMode");
+
+         /* Blitting. */
+         rect.x = i;
+         rect.y = j;
+         ret = SDL_BlitSurface( face, NULL, testsur, &rect );
+         AssertTrue(ret == 0, "SDL_BlitSurface");
+      }
+   }
+
+   /* Check to see if matches. */
+   AssertTrue(surface_compare( testsur, &img_blendAll, 0 ) == 0,
+		      "Blitting blending output not the same (using SDL_BLEND_*).");
+
+   /* Clean up. */
+   SDL_FreeSurface( face );
+   SDL_FreeSurface( testsur );
+
+   SDL_Quit();
+}
+
+#endif