marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

d3d9: Use separate fields for data to check/apply in the stateblock tests.

oldstable
Henri Verbeet 2009-10-07 09:02:57 +02:00 committed by Alexandre Julliard
parent fb5079815d
commit 3cb7e87284
1 changed files with 79 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
dlls/d3d9/tests/stateblock.c
View File

@ -139,13 +139,8 @@ struct state_test
void* test_context;
};
/* See below for explanation of the flags */
#define EVENT_OK 0x00
#define EVENT_CHECK_DEFAULT 0x01
#define EVENT_CHECK_INITIAL 0x02
#define EVENT_CHECK_TEST 0x04
#define EVENT_ERROR 0x08
#define EVENT_APPLY_DATA 0x10
#define EVENT_OK 0
#define EVENT_ERROR -1
struct event_data
{
@ -154,12 +149,43 @@ struct event_data
IDirect3DSwapChain9 *new_swap_chain;
};
enum stateblock_data
{
SB_DATA_NONE = 0,
SB_DATA_DEFAULT,
SB_DATA_INITIAL,
SB_DATA_TEST_IN,
SB_DATA_TEST,
};
struct event
{
int (*event_fn)(IDirect3DDevice9 *device, struct event_data *event_data);
int status;
enum stateblock_data check;
enum stateblock_data apply;
};
static const void *get_event_data(const struct state_test *test, enum stateblock_data data)
{
switch (data)
{
case SB_DATA_DEFAULT:
return test->default_data;
case SB_DATA_INITIAL:
return test->initial_data;
case SB_DATA_TEST_IN:
return test->test_data_in;
case SB_DATA_TEST:
return test->test_data_out;
default:
return NULL;
}
}
/* This is an event-machine, which tests things.
* It tests get and set operations for a batch of states, based on
* results from the event function, which directs what's to be done */
@ -167,51 +193,39 @@ struct event
static void execute_test_chain(IDirect3DDevice9 *device, struct state_test *test,
unsigned int ntests, struct event *event, unsigned int nevents, struct event_data *event_data)
{
int outcome;
unsigned int i = 0, j;
unsigned int i, j;
/* For each queued event */
for (j=0; j < nevents; j++) {
for (j = 0; j < nevents; ++j)
{
const void *data;
/* Execute the next event handler (if available) or just set the supplied status */
outcome = event[j].status;
/* Execute the next event handler (if available). */
if (event[j].event_fn)
outcome |= event[j].event_fn(device, event_data);
/* Now verify correct outcome depending on what was signaled by the handler.
* An EVENT_CHECK_TEST signal means check the returned data against the test_data (out).
* An EVENT_CHECK_DEFAULT signal means check the returned data against the default_data.
* An EVENT_CHECK_INITIAL signal means check the returned data against the initial_data.
* An EVENT_ERROR signal means the test isn't going to work, exit the event loop.
* An EVENT_APPLY_DATA signal means load the test data (after checks) */
if (outcome & EVENT_ERROR) {
trace("Test %s, Stage %u in error state, aborting\n", test[i].test_name, j);
break;
}
else if (outcome & (EVENT_CHECK_TEST | EVENT_CHECK_DEFAULT | EVENT_CHECK_INITIAL))
{
for (i = 0; i < ntests; ++i)
if (event[j].event_fn(device, event_data) == EVENT_ERROR)
{
if (outcome & EVENT_CHECK_TEST)
{
test[i].check_data(device, j, &test[i], test[i].test_data_out);
}
else if (outcome & EVENT_CHECK_DEFAULT)
{
test[i].check_data(device, j, &test[i], test[i].default_data);
}
else if (outcome & EVENT_CHECK_INITIAL)
{
test[i].check_data(device, j, &test[i], test[i].initial_data);
}
trace("Stage %u in error state, aborting.\n", j);
break;
}
}
if (outcome & EVENT_APPLY_DATA) {
for (i=0; i < ntests; i++)
test[i].set_handler(device, &test[i], test[i].test_data_in);
if (event[j].check != SB_DATA_NONE)
{
for (i = 0; i < ntests; ++i)
{
data = get_event_data(&test[i], event[j].check);
test[i].check_data(device, j, &test[i], data);
}
}
if (event[j].apply != SB_DATA_NONE)
{
for (i = 0; i < ntests; ++i)
{
data = get_event_data(&test[i], event[j].apply);
test[i].set_handler(device, &test[i], data);
}
}
}
@ -341,51 +355,51 @@ static void execute_test_chain_all(IDirect3DDevice9 *device, struct state_test *
struct event read_events[] =
{
{ NULL, EVENT_CHECK_INITIAL }
{NULL, SB_DATA_INITIAL, SB_DATA_NONE},
};
struct event write_read_events[] =
{
{ NULL, EVENT_APPLY_DATA },
{ NULL, EVENT_CHECK_TEST }
{NULL, SB_DATA_NONE, SB_DATA_TEST_IN},
{NULL, SB_DATA_TEST, SB_DATA_NONE},
};
struct event abort_stateblock_events[] =
{
{ begin_stateblock, EVENT_APPLY_DATA },
{ end_stateblock, EVENT_OK },
{ abort_stateblock, EVENT_CHECK_DEFAULT }
{begin_stateblock, SB_DATA_NONE, SB_DATA_TEST_IN},
{end_stateblock, SB_DATA_NONE, SB_DATA_NONE},
{abort_stateblock, SB_DATA_DEFAULT, SB_DATA_NONE},
};
struct event apply_stateblock_events[] =
{
{ begin_stateblock, EVENT_APPLY_DATA },
{ end_stateblock, EVENT_OK },
{ apply_stateblock, EVENT_CHECK_TEST }
{begin_stateblock, SB_DATA_NONE, SB_DATA_TEST_IN},
{end_stateblock, SB_DATA_NONE, SB_DATA_NONE},
{apply_stateblock, SB_DATA_TEST, SB_DATA_NONE},
};
struct event capture_reapply_stateblock_events[] =
{
{ begin_stateblock, EVENT_APPLY_DATA },
{ end_stateblock, EVENT_OK },
{ capture_stateblock, EVENT_CHECK_DEFAULT | EVENT_APPLY_DATA },
{ apply_stateblock, EVENT_CHECK_DEFAULT }
{begin_stateblock, SB_DATA_NONE, SB_DATA_TEST_IN},
{end_stateblock, SB_DATA_NONE, SB_DATA_NONE},
{capture_stateblock, SB_DATA_DEFAULT, SB_DATA_TEST_IN},
{apply_stateblock, SB_DATA_DEFAULT, SB_DATA_NONE},
};
struct event rendertarget_switch_events[] =
{
{ NULL, EVENT_APPLY_DATA },
{ switch_render_target, EVENT_CHECK_TEST },
{ revert_render_target, EVENT_OK }
{NULL, SB_DATA_NONE, SB_DATA_TEST_IN},
{switch_render_target, SB_DATA_TEST, SB_DATA_NONE},
{revert_render_target, SB_DATA_NONE, SB_DATA_NONE},
};
struct event rendertarget_stateblock_events[] =
{
{ begin_stateblock, EVENT_APPLY_DATA },
{ switch_render_target, EVENT_CHECK_DEFAULT },
{ end_stateblock, EVENT_OK },
{ revert_render_target, EVENT_OK },
{ apply_stateblock, EVENT_CHECK_TEST }
{begin_stateblock, SB_DATA_NONE, SB_DATA_TEST_IN},
{switch_render_target, SB_DATA_DEFAULT, SB_DATA_NONE},
{end_stateblock, SB_DATA_NONE, SB_DATA_NONE},
{revert_render_target, SB_DATA_NONE, SB_DATA_NONE},
{apply_stateblock, SB_DATA_TEST, SB_DATA_NONE},
};
/* Setup each test for execution */