[D3D9 3/8] Add init/teardown handlers for state tests
Ivan Gyurdiev
ivg231 at gmail.com
Mon Oct 2 19:12:53 CDT 2006
Replace on-stack buffer with init/teardown handlers, and heap allocation.
Why:
- because that's easier to maintain than tracking how much memory each
test uses
- because that will be necessary for more complicated tests in the
future, such as the one I'm writing for textures.
-------------- next part --------------
>From ace659191b06a13f5a4f5afed29d71921b342ab0 Mon Sep 17 00:00:00 2001
From: Ivan Gyurdiev <ivg2 at cornell.edu>
Date: Mon, 2 Oct 2006 19:33:39 -0400
Subject: [PATCH] Add init/teardown handlers for state tests.
Replace on-stack buffer with init/teardown handlers, and heap allocation.
Why:
- because that's easier to maintain than tracking how much memory each test uses
- because that will be necessary for more complicated tests in the future, such as the one I'm writing for textures.
---
dlls/d3d9/tests/stateblock.c | 217 +++++++++++++++++++++++++++++-------------
1 files changed, 152 insertions(+), 65 deletions(-)
diff --git a/dlls/d3d9/tests/stateblock.c b/dlls/d3d9/tests/stateblock.c
index 46500ff..57e241d 100644
--- a/dlls/d3d9/tests/stateblock.c
+++ b/dlls/d3d9/tests/stateblock.c
@@ -123,12 +123,19 @@ typedef struct state_test {
/* Return buffer */
void* return_data;
+ /* Size of the data samples above */
unsigned int data_size;
+ /* 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 struct state_test* test, const void* data_in);
void (*get_handler) (IDirect3DDevice9* device, const struct state_test* test, const void* data_out);
void (*print_handler) (const void* data);
+ /* Test arguments */
void* test_arg;
} state_test;
@@ -186,6 +193,7 @@ static void execute_test_chain(
memcpy(test[i].return_data, test[i].poison_data, test[i].data_size);
test[i].get_handler(device, &test[i], test[i].return_data);
+
if ((outcome & EVENT_CHECK_TEST) &&
memcmp(test[i].test_data_out, test[i].return_data, test[i].data_size)) {
@@ -384,6 +392,7 @@ static void execute_test_chain_all(
state_test* test,
unsigned int ntests) {
+ unsigned int i;
event_data arg;
event read_events[] = {
@@ -428,6 +437,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);
@@ -448,6 +465,10 @@ 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);
+
+ /* Cleanup resources */
+ for (i=0; i < ntests; i++)
+ test[i].teardown_handler(&test[i]);
}
/* =================== State test: Pixel and Vertex Shader constants ============ */
@@ -549,23 +570,37 @@ static const shader_constant_data shader
{ TRUE, FALSE, FALSE, TRUE }
};
-#define SHADER_CONSTANTS_REQ_BUFFER sizeof(shader_constant_data)
-
-static void shader_constants_queue_test(
- IDirect3DDevice9 *device,
- state_test* test,
- shader_constant_arg* test_arg,
- void* buffer)
-{
- shader_constant_data* return_data = buffer;
+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->return_data = return_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,
+ 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;
@@ -681,23 +716,37 @@ 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)
+static HRESULT light_setup_handler(
+ state_test* test) {
-static void lights_queue_test(
- IDirect3DDevice9 *device,
- state_test* test,
- light_arg* test_arg,
- void* buffer)
-{
- light_data* return_data = buffer;
+ 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->return_data = return_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,
+ 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;
@@ -840,22 +889,36 @@ 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) {
-static void transform_queue_test(
- IDirect3DDevice9 *device,
- state_test* test,
- void* buffer)
-{
- transform_data* return_data = buffer;
+ 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;
- 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(
+ IDirect3DDevice9 *device,
+ 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;
@@ -979,6 +1042,10 @@ 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 state_test* test, const void* data) {
@@ -1251,35 +1318,60 @@ #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->test_name = "set_get_render_states";
- test->test_arg = NULL;
+ test->test_arg = test_arg;
}
/* =================== Main state tests function =============================== */
@@ -1296,17 +1388,13 @@ static void test_state_management(
1 for transforms
1 for render states
*/
- state_test tests[2 + 1 + 1 + 1];
- BYTE buffer[SHADER_CONSTANTS_REQ_BUFFER * 2 +
- LIGHTS_REQ_BUFFER +
- TRANSFORMS_REQ_BUFFER +
- RENDER_STATES_REQ_BUFFER];
-
+ const int max_tests = 5;
+ state_test tests[5];
unsigned int tcount = 0;
- unsigned int bcount = 0;
shader_constant_arg pshader_constant_arg;
shader_constant_arg vshader_constant_arg;
+ render_state_arg render_state_arg;
light_arg light_arg;
hret = IDirect3DDevice9_GetDeviceCaps(device, &caps);
@@ -1315,33 +1403,32 @@ static void test_state_management(
texture_stages = caps.MaxTextureBlendStages;
+ /* Zero test memory */
+ memset(tests, 0, sizeof(state_test) * max_tests);
+
if (caps.VertexShaderVersion & 0xffff) {
vshader_constant_arg.idx = 0;
vshader_constant_arg.pshader = FALSE;
- shader_constants_queue_test(device, &tests[tcount], &vshader_constant_arg, &buffer[bcount]);
- bcount += SHADER_CONSTANTS_REQ_BUFFER;
+ shader_constants_queue_test(device, &tests[tcount], &vshader_constant_arg);
tcount++;
}
if (caps.PixelShaderVersion & 0xffff) {
pshader_constant_arg.idx = 0;
pshader_constant_arg.pshader = TRUE;
- shader_constants_queue_test(device, &tests[tcount], &pshader_constant_arg, &buffer[bcount]);
- bcount += SHADER_CONSTANTS_REQ_BUFFER;
+ shader_constants_queue_test(device, &tests[tcount], &pshader_constant_arg);
tcount++;
}
light_arg.idx = 0;
- lights_queue_test(device, &tests[tcount], &light_arg, &buffer[bcount]);
- bcount += LIGHTS_REQ_BUFFER;
+ lights_queue_test(device, &tests[tcount], &light_arg);
tcount++;
- transform_queue_test(device, &tests[tcount], &buffer[bcount]);
- bcount += TRANSFORMS_REQ_BUFFER;
+ transform_queue_test(device, &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(device, &tests[tcount], &render_state_arg);
tcount++;
execute_test_chain_all(device, tests, tcount);
--
1.4.2.1
More information about the wine-patches
mailing list