[D3D9] Update state test framework
Ivan Gyurdiev
ivg231 at gmail.com
Sun Sep 24 01:29:40 CDT 2006
Same patch, with a 2 line fix to make sure that a failed setup causes a
complete halt of the test system.
This case may be reached if the test is broken... or on out-of-memory.
-------------- next part --------------
---
dlls/d3d9/tests/stateblock.c | 315 ++++++++++++++++++++++++++----------------
1 files changed, 198 insertions(+), 117 deletions(-)
diff --git a/dlls/d3d9/tests/stateblock.c b/dlls/d3d9/tests/stateblock.c
index 3eb5d6e..3f5295a 100644
--- a/dlls/d3d9/tests/stateblock.c
+++ b/dlls/d3d9/tests/stateblock.c
@@ -97,38 +97,45 @@ static void test_begin_end_state_block(I
/* ============================ State Testing Framework ========================== */
typedef struct state_test {
+
const char* test_name;
/* The initial data is usually the same
* as the default data, but a write can have side effects.
* The initial data is tested first, before any writes take place
* The default data can be tested after a write */
- const void* initial_data;
+ void* initial_data;
/* The default data is the standard state to compare
* against, and restore to */
- const void* default_data;
+ void* default_data;
/* The test data is the experiment data to try
* in - what we want to write
* out - what windows will actually write (not necessarily the same) */
- const void* test_data_in;
- const void* test_data_out;
+ void* test_data_in;
+ void* test_data_out;
/* The poison data is the data to preinitialize the return buffer to */
- const void* poison_data;
+ void* poison_data;
/* Return buffer */
void* return_data;
+ /* Size of the data structure to represent data in the samples above */
unsigned int data_size;
- void (*set_handler) (IDirect3DDevice9* device, const void* data, void* set_arg);
- void (*get_handler) (IDirect3DDevice9* device, const void* data, void* get_arg);
+ /* Test resource management handlers */
+ HRESULT (*setup_handler) (struct state_test* test);
+ void (*teardown_handler) (struct state_test* test);
+
+ /* Test data handlers */
+ void (*set_handler) (IDirect3DDevice9* device, const void* data, const void* test_arg);
+ void (*get_handler) (IDirect3DDevice9* device, const void* data, const void* test_arg);
void (*print_handler) (const void* data);
- void* set_arg;
- void* get_arg;
+ /* Caller supplied test arguments */
+ void* test_arg;
} state_test;
@@ -184,7 +191,7 @@ static void execute_test_chain(
for (i=0; i < ntests; i++) {
memcpy(test[i].return_data, test[i].poison_data, test[i].data_size);
- test[i].get_handler(device, test[i].return_data, test[i].get_arg);
+ test[i].get_handler(device, test[i].return_data, test[i].test_arg);
if ((outcome & EVENT_CHECK_TEST) &&
memcmp(test[i].test_data_out, test[i].return_data, test[i].data_size)) {
@@ -231,13 +238,13 @@ static void execute_test_chain(
if (outcome & EVENT_APPLY_DATA) {
for (i=0; i < ntests; i++)
- test[i].set_handler(device, test[i].test_data_in, test[i].set_arg);
+ test[i].set_handler(device, test[i].test_data_in, test[i].test_arg);
}
}
- /* Attempt to reset any changes made */
+ /* Attempt to reset any changes made. */
for (i=0; i < ntests; i++)
- test[i].set_handler(device, test[i].default_data, test[i].set_arg);
+ test[i].set_handler(device, test[i].default_data, test[i].test_arg);
}
typedef struct event_data {
@@ -384,6 +391,7 @@ static void execute_test_chain_all(
unsigned int ntests) {
event_data arg;
+ unsigned int i;
event read_events[] = {
{ NULL, EVENT_CHECK_INITIAL }
@@ -427,6 +435,14 @@ static void execute_test_chain_all(
{ apply_stateblock, EVENT_CHECK_TEST }
};
+ /* Setup each test for execution */
+ for (i=0; i < ntests; i++) {
+ if (test[i].setup_handler(&test[i]) != D3D_OK) {
+ ok(FALSE, "Test \"%s\" failed setup, aborting\n", test[i].test_name);
+ return;
+ }
+ }
+
trace("Running initial read state tests\n");
execute_test_chain(device, test, ntests, read_events, 1, NULL);
@@ -447,6 +463,9 @@ static void execute_test_chain_all(
trace("Running stateblock apply over rendertarget switch interrupt tests\n");
execute_test_chain(device, test, ntests, rendertarget_stateblock_events, 5, &arg);
+
+ for (i=0; i < ntests; i++)
+ test[i].teardown_handler(&test[i]);
}
/* =================== State test: Pixel and Vertex Shader constants ============ */
@@ -481,11 +500,11 @@ static void shader_constant_print_handle
}
static void shader_constant_set_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* test_arg) {
HRESULT hret;
shader_constant_data* scdata = (shader_constant_data*) data;
- shader_constant_arg* scarg = (shader_constant_arg*) arg;
+ shader_constant_arg* scarg = (shader_constant_arg*) test_arg;
unsigned int index = scarg->idx;
if (!scarg->pshader) {
@@ -507,11 +526,11 @@ static void shader_constant_set_handler(
}
static void shader_constant_get_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* test_arg) {
HRESULT hret;
shader_constant_data* scdata = (shader_constant_data*) data;
- shader_constant_arg* scarg = (shader_constant_arg*) arg;
+ shader_constant_arg* scarg = (shader_constant_arg*) test_arg;
unsigned int index = scarg->idx;
if (!scarg->pshader) {
@@ -548,32 +567,41 @@ static const shader_constant_data shader
{ TRUE, FALSE, FALSE, TRUE }
};
-#define SHADER_CONSTANTS_REQ_BUFFER \
- (sizeof(shader_constant_data) + sizeof(shader_constant_arg))
+static HRESULT shader_constant_setup_handler(
+ state_test* test) {
+
+ test->return_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(shader_constant_data));
+ if (test->return_data == NULL)
+ return E_FAIL;
+
+ test->test_data_in = (void*) &shader_constant_test_data;
+ test->test_data_out = (void*) &shader_constant_test_data;
+ test->default_data = (void*) &shader_constant_default_data;
+ test->initial_data = (void*) &shader_constant_default_data;
+ test->poison_data = (void*) &shader_constant_poison_data;
+
+ test->data_size = sizeof(shader_constant_data);
+
+ return D3D_OK;
+}
+
+static void shader_constant_teardown_handler(
+ state_test* test) {
+
+ HeapFree(GetProcessHeap(), 0, test->return_data);
+}
static void shader_constants_queue_test(
- IDirect3DDevice9 *device,
state_test* test,
- void* buffer,
- BOOL pshader)
-{
- shader_constant_arg* arg = buffer;
- shader_constant_data* return_data = (shader_constant_data*) (arg + 1);
-
- test->test_data_in = &shader_constant_test_data;
- test->test_data_out = &shader_constant_test_data;
- test->default_data = &shader_constant_default_data;
- test->initial_data = &shader_constant_default_data;
- test->poison_data = &shader_constant_poison_data;
- test->return_data = return_data;
- test->data_size = sizeof(shader_constant_data);
+ shader_constant_arg* test_arg) {
+
+ test->setup_handler = shader_constant_setup_handler;
+ test->teardown_handler = shader_constant_teardown_handler;
test->set_handler = shader_constant_set_handler;
test->get_handler = shader_constant_get_handler;
test->print_handler = shader_constant_print_handler;
- test->get_arg = test->set_arg = arg;
- test->test_name = pshader? "set_get_pshader_constants": "set_get_vshader_constants";
- arg->idx = 0;
- arg->pshader = pshader;
+ test->test_name = test_arg->pshader? "set_get_pshader_constants": "set_get_vshader_constants";
+ test->test_arg = test_arg;
}
/* =================== State test: Lights ===================================== */
@@ -622,11 +650,11 @@ static void light_print_handler(
}
static void light_set_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* test_arg) {
HRESULT hret;
light_data* ldata = (light_data*) data;
- light_arg* larg = (light_arg*) arg;
+ light_arg* larg = (light_arg*) test_arg;
unsigned int index = larg->idx;
hret = IDirect3DDevice9_SetLight(device, index, &ldata->light);
@@ -637,11 +665,11 @@ static void light_set_handler(
}
static void light_get_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* test_arg) {
HRESULT hret;
light_data* ldata = (light_data*) data;
- light_arg* larg = (light_arg*) arg;
+ light_arg* larg = (light_arg*) test_arg;
unsigned int index = larg->idx;
hret = IDirect3DDevice9_GetLightEnable(device, index, &ldata->enabled);
@@ -684,30 +712,41 @@ static const light_data light_test_data_
{ 5.0, 5.0, 5.0 }, { 6.0, 6.0, 6.0 },
7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 }, 128, D3D_OK, D3D_OK};
-#define LIGHTS_REQ_BUFFER \
- (sizeof(light_data) + sizeof(light_arg))
+static HRESULT light_setup_handler(
+ state_test* test) {
+
+ test->return_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(light_data));
+ if (test->return_data == NULL)
+ return E_FAIL;
+
+ test->test_data_in = (void*) &light_test_data_in;
+ test->test_data_out = (void*) &light_test_data_out;
+ test->default_data = (void*) &light_default_data;
+ test->initial_data = (void*) &light_initial_data;
+ test->poison_data = (void*) &light_poison_data;
+
+ test->data_size = sizeof(light_data);
+
+ return D3D_OK;
+}
+
+static void light_teardown_handler(
+ state_test* test) {
+
+ HeapFree(GetProcessHeap(), 0, test->return_data);
+}
static void lights_queue_test(
- IDirect3DDevice9 *device,
state_test* test,
- void* buffer)
-{
- light_arg* arg = buffer;
- light_data* return_data = (light_data*) (arg + 1);
-
- test->test_data_in = &light_test_data_in;
- test->test_data_out = &light_test_data_out;
- test->default_data = &light_default_data;
- test->initial_data = &light_initial_data;
- test->poison_data = &light_poison_data;
- test->return_data = return_data;
- test->data_size = sizeof(light_data);
+ light_arg* test_arg) {
+
+ test->setup_handler = light_setup_handler;
+ test->teardown_handler = light_teardown_handler;
test->set_handler = light_set_handler;
test->get_handler = light_get_handler;
test->print_handler = light_print_handler;
- test->get_arg = test->set_arg = arg;
test->test_name = "set_get_light";
- arg->idx = 0;
+ test->test_arg = test_arg;
}
/* =================== State test: Transforms ===================================== */
@@ -747,7 +786,7 @@ static void transform_print_handler(
}
static void transform_set_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* arg) {
HRESULT hret;
transform_data* tdata = (transform_data*) data;
@@ -772,7 +811,7 @@ static void transform_set_handler(
}
static void transform_get_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* arg) {
HRESULT hret;
transform_data* tdata = (transform_data*) data;
@@ -845,26 +884,38 @@ static const transform_data transform_te
2.56, 1.829, 23.6, -1.0, 112.3, 0.0, 41.4, 2.5 } } },
};
-#define TRANSFORMS_REQ_BUFFER (sizeof(transform_data))
+static HRESULT transform_setup_handler(
+ state_test* test) {
+
+ test->return_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(transform_data));
+ if (test->return_data == NULL)
+ return E_FAIL;
+
+ test->test_data_in = (void*) &transform_test_data;
+ test->test_data_out = (void*) &transform_test_data;
+ test->default_data = (void*) &transform_default_data;
+ test->initial_data = (void*) &transform_default_data;
+ test->poison_data = (void*) &transform_poison_data;
-static void transform_queue_test(
- IDirect3DDevice9 *device,
- state_test* test,
- void* buffer)
-{
- transform_data* return_data = buffer;
-
- test->test_data_in = &transform_test_data;
- test->test_data_out = &transform_test_data;
- test->default_data = &transform_default_data;
- test->initial_data = &transform_default_data;
- test->poison_data = &transform_poison_data;
- test->return_data = return_data;
test->data_size = sizeof(transform_data);
+
+ return D3D_OK;
+}
+
+static void transform_teardown_handler(
+ state_test* test) {
+
+ HeapFree(GetProcessHeap(), 0, test->return_data);
+}
+
+static void transform_queue_test(
+ state_test* test) {
+
+ test->setup_handler = transform_setup_handler;
+ test->teardown_handler = transform_teardown_handler;
test->set_handler = transform_set_handler;
test->get_handler = transform_get_handler;
test->print_handler = transform_print_handler;
- test->get_arg = test->set_arg = NULL;
test->test_name = "set_get_transforms";
}
@@ -984,8 +1035,12 @@ typedef struct render_state_data {
DWORD states[D3D9_RENDER_STATES];
} render_state_data;
+typedef struct render_state_arg {
+ D3DPRESENT_PARAMETERS* device_pparams;
+} render_state_arg;
+
static void render_state_set_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* test_arg) {
HRESULT hret;
render_state_data* rsdata = (render_state_data*) data;
@@ -998,7 +1053,7 @@ static void render_state_set_handler(
}
static void render_state_get_handler(
- IDirect3DDevice9* device, const void* data, void* arg) {
+ IDirect3DDevice9* device, const void* data, const void* test_arg) {
HRESULT hret;
render_state_data* rsdata = (render_state_data*) data;
@@ -1256,35 +1311,59 @@ #endif
data->states[idx++] = FALSE; /* BLENDOPALPHA */
}
-#define RENDER_STATES_REQ_BUFFER (sizeof(render_state_data) * 4)
+static HRESULT render_state_setup_handler(
+ state_test* test) {
+
+ render_state_arg* rsarg = (render_state_arg*) test->test_arg;
+
+ test->return_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(render_state_data));
+ if (test->return_data == NULL)
+ return E_FAIL;
+
+ test->default_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(render_state_data));
+ if (test->default_data == NULL)
+ return E_FAIL;
+
+ test->test_data_in = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(render_state_data));
+ if (test->test_data_in == NULL)
+ return E_FAIL;
+
+ test->poison_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(render_state_data));
+ if (test->poison_data == NULL)
+ return E_FAIL;
+
+ render_state_default_data_init(rsarg->device_pparams, test->default_data);
+ render_state_test_data_init(test->test_data_in);
+ render_state_poison_data_init(test->poison_data);
+
+ test->initial_data = test->default_data;
+ test->test_data_out = test->test_data_in;
+
+ test->data_size = sizeof(render_state_data);
+
+ return D3D_OK;
+}
+
+static void render_state_teardown_handler(
+ state_test* test) {
+
+ HeapFree(GetProcessHeap(), 0, test->return_data);
+ HeapFree(GetProcessHeap(), 0, test->default_data);
+ HeapFree(GetProcessHeap(), 0, test->test_data_in);
+ HeapFree(GetProcessHeap(), 0, test->poison_data);
+}
static void render_states_queue_test(
- IDirect3DDevice9 *device,
- D3DPRESENT_PARAMETERS *device_pparams,
state_test* test,
- void* buffer)
-{
- render_state_data* return_data = buffer;
- render_state_data* default_data = return_data + 1;
- render_state_data* test_data = default_data + 1;
- render_state_data* poison_data = test_data + 1;
-
- render_state_default_data_init(device_pparams, default_data);
- render_state_test_data_init(test_data);
- render_state_poison_data_init(poison_data);
-
- test->test_data_in = test_data;
- test->test_data_out = test_data;
- test->default_data = default_data;
- test->initial_data = default_data;
- test->poison_data = poison_data;
- test->return_data = return_data;
- test->data_size = sizeof(render_state_data);
+ render_state_arg* test_arg) {
+
+ test->setup_handler = render_state_setup_handler;
+ test->teardown_handler = render_state_teardown_handler;
test->set_handler = render_state_set_handler;
test->get_handler = render_state_get_handler;
test->print_handler = render_state_print_handler;
- test->get_arg = test->set_arg = NULL;
test->test_name = "set_get_render_states";
+ test->test_arg = test_arg;
}
/* =================== Main state tests function =============================== */
@@ -1302,43 +1381,45 @@ static void test_state_management(
1 for render states
*/
const int max_tests = 2 + 1 + 1 + 1;
- const int max_buffer = SHADER_CONSTANTS_REQ_BUFFER * 2 +
- LIGHTS_REQ_BUFFER +
- TRANSFORMS_REQ_BUFFER +
- RENDER_STATES_REQ_BUFFER;
-
unsigned int tcount = 0;
- unsigned int bcount = 0;
-
state_test tests[max_tests];
- BYTE buffer[max_buffer];
+
+ /* Test arguments */
+ shader_constant_arg pshader_constant_arg;
+ shader_constant_arg vshader_constant_arg;
+ render_state_arg render_state_arg;
+ light_arg light_arg;
+
+ /* Initialize all fields to 0 */
+ memset(tests, 0, sizeof(state_test) * max_tests);
hret = IDirect3DDevice9_GetDeviceCaps(device, &caps);
ok(hret == D3D_OK, "GetDeviceCaps returned %#lx.\n", hret);
if (hret != D3D_OK) return;
if (caps.VertexShaderVersion & 0xffff) {
- shader_constants_queue_test(device, &tests[tcount], &buffer[bcount], FALSE);
- bcount += SHADER_CONSTANTS_REQ_BUFFER;
+ vshader_constant_arg.pshader = FALSE;
+ vshader_constant_arg.idx = 0;
+ shader_constants_queue_test(&tests[tcount], &vshader_constant_arg);
tcount++;
}
if (caps.PixelShaderVersion & 0xffff) {
- shader_constants_queue_test(device, &tests[tcount], &buffer[bcount], TRUE);
- bcount += SHADER_CONSTANTS_REQ_BUFFER;
+ pshader_constant_arg.pshader = TRUE;
+ pshader_constant_arg.idx = 0;
+ shader_constants_queue_test(&tests[tcount], &pshader_constant_arg);
tcount++;
}
- lights_queue_test(device, &tests[tcount], &buffer[bcount]);
- bcount += LIGHTS_REQ_BUFFER;
+ light_arg.idx = 0;
+ lights_queue_test(&tests[tcount], &light_arg);
tcount++;
- transform_queue_test(device, &tests[tcount], &buffer[bcount]);
- bcount += TRANSFORMS_REQ_BUFFER;
+ transform_queue_test(&tests[tcount]);
tcount++;
- render_states_queue_test(device, device_pparams, &tests[tcount], &buffer[bcount]);
- bcount += RENDER_STATES_REQ_BUFFER;
+ render_state_arg.device_pparams = device_pparams;
+ render_states_queue_test(&tests[tcount], &render_state_arg);
tcount++;
execute_test_chain_all(device, tests, tcount);
--
1.4.2
More information about the wine-patches
mailing list