bbcbece6c9
This patch reworks our conformance testing framework because it seems that glib's gtesting framework isn't really well suited to our use case. For example we weren't able to test windows builds given the way we were using it and also for each test we'd like to repeat the test with several different environments so we can test important driver and feature combinations. This patch instead switches away to a simplified but custom approach for running our unit tests. We hope that having a more bespoke setup will enable us to easily extend it to focus on the details important to us. Notable changes with this new approach are: We can now run 'make test' for our mingw windows builds. We've got rid of all the test-*report* make rules and we're just left with 'make test' 'make test' now runs each test several times with different driver and feature combinations checking the result for each run. 'make test' will then output a concise table of all of the results. The combinations tested are: - OpenGL Fixed Function - OpenGL ARBfp - OpenGL GLSL - OpenGL No NPOT texture support - OpenGLES 2.0 - OpenGLES 2.0 No NPOT texture support Reviewed-by: Neil Roberts <neil@linux.intel.com>
331 lines
8.4 KiB
C
331 lines
8.4 KiB
C
#include <clutter/clutter.h>
|
|
#include <cogl/cogl.h>
|
|
#include <string.h>
|
|
|
|
#include "test-conform-common.h"
|
|
|
|
#define TILE_SIZE 32.0f
|
|
|
|
enum
|
|
{
|
|
TILE_MAP,
|
|
TILE_SET_DATA,
|
|
NB_TILES,
|
|
TILE_SET_REGION,
|
|
};
|
|
|
|
typedef struct test_tile
|
|
{
|
|
ClutterColor color;
|
|
gfloat x, y;
|
|
CoglHandle buffer;
|
|
CoglHandle texture;
|
|
} TestTile;
|
|
|
|
static const ClutterColor
|
|
buffer_colors[] =
|
|
{
|
|
};
|
|
|
|
static const ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff };
|
|
|
|
typedef struct _TestState
|
|
{
|
|
ClutterActor *stage;
|
|
unsigned int frame;
|
|
|
|
TestTile *tiles;
|
|
|
|
} TestState;
|
|
|
|
static CoglHandle
|
|
create_texture_from_buffer (CoglHandle buffer)
|
|
{
|
|
CoglHandle texture;
|
|
|
|
texture = cogl_texture_new_from_buffer (buffer,
|
|
TILE_SIZE, TILE_SIZE,
|
|
COGL_TEXTURE_NO_SLICING,
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
TILE_SIZE * 4,
|
|
0);
|
|
|
|
g_assert (texture != COGL_INVALID_HANDLE);
|
|
|
|
return texture;
|
|
}
|
|
|
|
static void
|
|
create_map_tile (TestTile *tile)
|
|
{
|
|
CoglHandle buffer;
|
|
guchar *map;
|
|
unsigned int i;
|
|
unsigned int stride = 0;
|
|
guint8 *line;
|
|
|
|
buffer = cogl_pixel_array_new_with_size (TILE_SIZE,
|
|
TILE_SIZE,
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
&stride);
|
|
|
|
g_assert (cogl_is_pixel_array (buffer));
|
|
g_assert (cogl_is_buffer (buffer));
|
|
|
|
cogl_buffer_set_update_hint (buffer, COGL_BUFFER_UPDATE_HINT_DYNAMIC);
|
|
g_assert_cmpint (cogl_buffer_get_update_hint (buffer),
|
|
==,
|
|
COGL_BUFFER_UPDATE_HINT_DYNAMIC);
|
|
|
|
map = cogl_buffer_map (buffer,
|
|
COGL_BUFFER_ACCESS_WRITE,
|
|
COGL_BUFFER_MAP_HINT_DISCARD);
|
|
g_assert (map);
|
|
|
|
line = g_alloca (TILE_SIZE * 4);
|
|
for (i = 0; i < TILE_SIZE * 4; i += 4)
|
|
memcpy (line + i, &tile->color, 4);
|
|
|
|
for (i = 0; i < TILE_SIZE; i++)
|
|
memcpy (map + stride * i, line, TILE_SIZE * 4);
|
|
|
|
cogl_buffer_unmap (buffer);
|
|
|
|
tile->buffer = buffer;
|
|
tile->texture = create_texture_from_buffer (tile->buffer);
|
|
}
|
|
|
|
#if 0
|
|
static void
|
|
create_set_region_tile (TestTile *tile)
|
|
{
|
|
CoglHandle buffer;
|
|
ClutterColor bottom_color;
|
|
unsigned int rowstride = 0;
|
|
guchar *data;
|
|
unsigned int i;
|
|
|
|
buffer = cogl_pixel_array_with_size (TILE_SIZE,
|
|
TILE_SIZE,
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
&rowstride);
|
|
|
|
g_assert (cogl_is_pixel_array (buffer));
|
|
g_assert (cogl_is_buffer (buffer));
|
|
|
|
/* while at it, set/get the hint */
|
|
cogl_buffer_set_hint (buffer, COGL_BUFFER_HINT_STATIC_TEXTURE);
|
|
g_assert (cogl_buffer_get_hint (buffer) == COGL_BUFFER_HINT_STATIC_TEXTURE);
|
|
|
|
data = g_malloc (TILE_SIZE * TILE_SIZE * 4);
|
|
/* create a buffer with the data we want to copy to the buffer */
|
|
for (i = 0; i < TILE_SIZE * TILE_SIZE * 4; i += 4)
|
|
memcpy (data + i, &tile->color, 4);
|
|
|
|
cogl_pixel_array_set_region (buffer,
|
|
data,
|
|
TILE_SIZE, TILE_SIZE,
|
|
TILE_SIZE,
|
|
0, 0);
|
|
|
|
bottom_color.red = tile->color.red;
|
|
bottom_color.green = tile->color.blue;
|
|
bottom_color.blue = tile->color.green;
|
|
bottom_color.alpha = tile->color.alpha;
|
|
for (i = 0; i < TILE_SIZE / 2; i++)
|
|
memcpy (data + i, &bottom_color, 4);
|
|
|
|
cogl_buffer_set_data (buffer, data, 0, TILE_SIZE * TILE_SIZE * 4 / 2);
|
|
|
|
g_free (data);
|
|
|
|
tile->buffer = buffer;
|
|
tile->texture = create_texture_from_buffer (tile->buffer);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
create_set_data_tile (TestTile *tile)
|
|
{
|
|
CoglHandle buffer;
|
|
unsigned int rowstride = 0;
|
|
gboolean res;
|
|
guchar *data;
|
|
unsigned int i;
|
|
|
|
buffer = cogl_pixel_array_new_with_size (TILE_SIZE,
|
|
TILE_SIZE,
|
|
COGL_PIXEL_FORMAT_RGBA_8888,
|
|
&rowstride);
|
|
|
|
g_assert (cogl_is_pixel_array (buffer));
|
|
g_assert (cogl_is_buffer (buffer));
|
|
g_assert_cmpint (cogl_buffer_get_size (buffer), ==, rowstride * TILE_SIZE);
|
|
|
|
/* create a buffer with the data we want to copy to the buffer */
|
|
data = g_malloc (TILE_SIZE * TILE_SIZE * 4);
|
|
for (i = 0; i < TILE_SIZE * TILE_SIZE * 4; i += 4)
|
|
memcpy (data + i, &tile->color, 4);
|
|
|
|
/* FIXME: this doesn't consider the rowstride */
|
|
res = cogl_buffer_set_data (buffer, 0, data, TILE_SIZE * TILE_SIZE * 4);
|
|
g_assert (res);
|
|
|
|
g_free (data);
|
|
|
|
tile->buffer = buffer;
|
|
tile->texture = create_texture_from_buffer (tile->buffer);
|
|
}
|
|
|
|
static void
|
|
draw_frame (TestState *state)
|
|
{
|
|
unsigned int i;
|
|
|
|
/* Paint the textures */
|
|
for (i = 0; i < NB_TILES; i++)
|
|
{
|
|
cogl_set_source_texture (state->tiles[i].texture);
|
|
cogl_rectangle (state->tiles[i].x,
|
|
state->tiles[i].y,
|
|
state->tiles[i].x + TILE_SIZE,
|
|
state->tiles[i].y + TILE_SIZE);
|
|
}
|
|
|
|
}
|
|
|
|
static gboolean
|
|
validate_tile (TestState *state,
|
|
TestTile *tile)
|
|
{
|
|
int x, y;
|
|
guchar *pixels, *p;
|
|
|
|
p = pixels = clutter_stage_read_pixels (CLUTTER_STAGE (state->stage),
|
|
tile->x,
|
|
tile->y,
|
|
TILE_SIZE,
|
|
TILE_SIZE);
|
|
|
|
/* Check whether the center of each division is the right color */
|
|
for (y = 0; y < TILE_SIZE; y++)
|
|
for (x = 0; x < TILE_SIZE; x++)
|
|
{
|
|
if (p[0] != tile->color.red ||
|
|
p[1] != tile->color.green ||
|
|
p[2] != tile->color.blue ||
|
|
p[3] != tile->color.alpha)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
p += 4;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
validate_result (TestState *state)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < NB_TILES; i++)
|
|
g_assert (validate_tile (state, &state->tiles[i]));
|
|
|
|
/* comment this if you want to see what's being drawn */
|
|
#if 1
|
|
clutter_main_quit ();
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
on_paint (ClutterActor *actor, TestState *state)
|
|
{
|
|
int frame_num;
|
|
|
|
draw_frame (state);
|
|
|
|
/* XXX: validate_result calls clutter_stage_read_pixels which will result in
|
|
* another paint run so to avoid infinite recursion we only aim to validate
|
|
* the first frame. */
|
|
frame_num = state->frame++;
|
|
if (frame_num == 1)
|
|
validate_result (state);
|
|
}
|
|
|
|
static gboolean
|
|
queue_redraw (gpointer stage)
|
|
{
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
test_cogl_pixel_array (TestUtilsGTestFixture *fixture,
|
|
void * data)
|
|
{
|
|
TestState state;
|
|
unsigned int idle_source;
|
|
unsigned int paint_handler, i;
|
|
static TestTile tiles[NB_TILES] =
|
|
{
|
|
/* color x y buffer tex */
|
|
|
|
/* MAP */
|
|
{ { 0xff, 0x00, 0x00, 0xff }, 0.0f, 0.0f, NULL, NULL },
|
|
#if 0
|
|
/* SET_REGION */
|
|
{ { 0x7e, 0x7e, 0xff, 0x7e }, 0.0f, TILE_SIZE, NULL, NULL },
|
|
#endif
|
|
/* SET_DATA */
|
|
{ { 0x7e, 0xff, 0x7e, 0xff }, 0.0f, TILE_SIZE, NULL, NULL }
|
|
};
|
|
|
|
state.frame = 0;
|
|
|
|
state.stage = clutter_stage_get_default ();
|
|
|
|
create_map_tile (&tiles[TILE_MAP]);
|
|
#if 0
|
|
create_set_region_tile (&tiles[TILE_SET_REGION]);
|
|
#endif
|
|
create_set_data_tile (&tiles[TILE_SET_DATA]);
|
|
|
|
state.tiles = tiles;
|
|
|
|
clutter_stage_set_color (CLUTTER_STAGE (state.stage), &stage_color);
|
|
|
|
/* We force continuous redrawing of the stage, since we need to skip
|
|
* the first few frames, and we wont be doing anything else that
|
|
* will trigger redrawing. */
|
|
idle_source = g_idle_add (queue_redraw, state.stage);
|
|
|
|
paint_handler = g_signal_connect_after (state.stage, "paint",
|
|
G_CALLBACK (on_paint), &state);
|
|
|
|
clutter_actor_show_all (state.stage);
|
|
|
|
clutter_main ();
|
|
|
|
g_source_remove (idle_source);
|
|
g_signal_handler_disconnect (state.stage, paint_handler);
|
|
|
|
for (i = 0; i < NB_TILES; i++)
|
|
{
|
|
cogl_handle_unref (state.tiles[i].buffer);
|
|
cogl_handle_unref (state.tiles[i].texture);
|
|
}
|
|
|
|
/* Remove all of the actors from the stage */
|
|
clutter_container_foreach (CLUTTER_CONTAINER (state.stage),
|
|
(ClutterCallback) clutter_actor_destroy,
|
|
NULL);
|
|
|
|
if (cogl_test_verbose ())
|
|
g_print ("OK\n");
|
|
}
|
|
|