janitorial: Remove remaining NULL checks before free() (found by Smatch).
[wine] / dlls / d3d9 / tests / stateblock.c
1 /*
2  * Copyright (C) 2005 Henri Verbeet
3  * Copyright (C) 2006 Ivan Gyurdiev
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #define COBJMACROS
21 #include <d3d9.h>
22 #include "wine/test.h"
23
24 static HMODULE d3d9_handle = 0;
25
26 static DWORD texture_stages;
27
28 static HWND create_window(void)
29 {
30     WNDCLASS wc = {0};
31     wc.lpfnWndProc = &DefWindowProc;
32     wc.lpszClassName = "d3d9_test_wc";
33     RegisterClass(&wc);
34
35     return CreateWindow("d3d9_test_wc", "d3d9_test",
36             0, 0, 0, 0, 0, 0, 0, 0, 0);
37 }
38
39 static HRESULT init_d3d9(
40     IDirect3DDevice9** device,
41     D3DPRESENT_PARAMETERS* device_pparams)
42 {
43     IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
44     IDirect3D9 *d3d9_ptr = 0;
45     HRESULT hres;
46     HWND window;
47
48     d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
49     ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
50     if (!d3d9_create) return E_FAIL;
51     
52     d3d9_ptr = d3d9_create(D3D_SDK_VERSION);
53     ok(d3d9_ptr != NULL, "Failed to create IDirect3D9 object\n");
54     if (!d3d9_ptr) return E_FAIL;
55
56     window = create_window();
57
58     ZeroMemory(device_pparams, sizeof(D3DPRESENT_PARAMETERS));
59     device_pparams->Windowed = TRUE;
60     device_pparams->hDeviceWindow = window;
61     device_pparams->SwapEffect = D3DSWAPEFFECT_DISCARD;
62
63     hres = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_NULLREF, window,
64         D3DCREATE_SOFTWARE_VERTEXPROCESSING, device_pparams, device);
65     ok(hres == D3D_OK, "IDirect3D_CreateDevice returned: 0x%x\n", hres);
66     return hres;
67 }
68
69 static void test_begin_end_state_block(IDirect3DDevice9 *device_ptr)
70 {
71     HRESULT hret = 0;
72     IDirect3DStateBlock9 *state_block_ptr = 0;
73
74     /* Should succeed */
75     hret = IDirect3DDevice9_BeginStateBlock(device_ptr);
76     ok(hret == D3D_OK, "BeginStateBlock returned: hret 0x%x. Expected hret 0x%x. Aborting.\n", hret, D3D_OK);
77     if (hret != D3D_OK) return;
78
79     /* Calling BeginStateBlock while recording should return D3DERR_INVALIDCALL */
80     hret = IDirect3DDevice9_BeginStateBlock(device_ptr);
81     ok(hret == D3DERR_INVALIDCALL, "BeginStateBlock returned: hret 0x%x. Expected hret 0x%x. Aborting.\n", hret, D3DERR_INVALIDCALL);
82     if (hret != D3DERR_INVALIDCALL) return;
83
84     /* Should succeed */
85     state_block_ptr = (IDirect3DStateBlock9 *)0xdeadbeef;
86     hret = IDirect3DDevice9_EndStateBlock(device_ptr, &state_block_ptr);
87     ok(hret == D3D_OK && state_block_ptr != 0 && state_block_ptr != (IDirect3DStateBlock9 *)0xdeadbeef, 
88         "EndStateBlock returned: hret 0x%x, state_block_ptr %p. "
89         "Expected hret 0x%x, state_block_ptr != %p, state_block_ptr != 0xdeadbeef.\n", hret, state_block_ptr, D3D_OK, NULL);
90
91     /* Calling EndStateBlock while not recording should return D3DERR_INVALIDCALL. state_block_ptr should not be touched. */
92     state_block_ptr = (IDirect3DStateBlock9 *)0xdeadbeef;
93     hret = IDirect3DDevice9_EndStateBlock(device_ptr, &state_block_ptr);
94     ok(hret == D3DERR_INVALIDCALL && state_block_ptr == (IDirect3DStateBlock9 *)0xdeadbeef, 
95         "EndStateBlock returned: hret 0x%x, state_block_ptr %p. "
96         "Expected hret 0x%x, state_block_ptr 0xdeadbeef.\n", hret, state_block_ptr, D3DERR_INVALIDCALL);
97 }
98
99 /* ============================ State Testing Framework ========================== */
100
101 typedef struct state_test {
102     const char* test_name;
103
104     /* The initial data is usually the same
105      * as the default data, but a write can have side effects.
106      * The initial data is tested first, before any writes take place
107      * The default data can be tested after a write */
108     const void* initial_data;
109
110     /* The default data is the standard state to compare
111      * against, and restore to */
112     const void* default_data;
113
114     /* The test data is the experiment data to try
115      * in - what we want to write
116      * out - what windows will actually write (not necessarily the same)  */
117     const void* test_data_in;
118     const void* test_data_out;
119
120     /* The poison data is the data to preinitialize the return buffer to */
121     const void* poison_data;
122     
123     /* Return buffer */
124     void* return_data;
125
126     /* Size of the data samples above */
127     unsigned int data_size;
128
129     /* Test resource management handlers */
130     HRESULT (*setup_handler) (struct state_test* test);
131     void (*teardown_handler) (struct state_test* test);
132
133     /* Test data handlers */
134     void (*set_handler) (IDirect3DDevice9* device, const struct state_test* test, const void* data_in);
135     void (*get_handler) (IDirect3DDevice9* device, const struct state_test* test, void* data_out);
136     void (*print_handler) (const void* data);
137
138     /* Test arguments */
139     const void* test_arg;
140
141     /* Test-specific context data */
142     void* test_context;
143
144 } state_test;
145
146 /* See below for explanation of the flags */
147 #define EVENT_OK             0x00
148 #define EVENT_CHECK_DEFAULT  0x01 
149 #define EVENT_CHECK_INITIAL  0x02
150 #define EVENT_CHECK_TEST     0x04
151 #define EVENT_ERROR          0x08
152 #define EVENT_APPLY_DATA     0x10
153
154 typedef struct event {
155    int (*event_fn) (IDirect3DDevice9* device, void* arg);
156    int status;
157 } event;
158
159 /* This is an event-machine, which tests things.
160  * It tests get and set operations for a batch of states, based on
161  * results from the event function, which directs what's to be done */
162
163 static void execute_test_chain(
164     IDirect3DDevice9* device,
165     state_test* test,
166     unsigned int ntests,
167     event *event,
168     unsigned int nevents,
169     void* event_arg) {
170
171     int outcome;
172     unsigned int i = 0, j;
173
174     /* For each queued event */
175     for (j=0; j < nevents; j++) {
176
177         /* Execute the next event handler (if available) or just set the supplied status */
178         outcome = event[j].status;
179         if (event[j].event_fn)
180             outcome |= event[j].event_fn(device, event_arg);
181
182         /* Now verify correct outcome depending on what was signaled by the handler.
183          * An EVENT_CHECK_TEST signal means check the returned data against the test_data (out).
184          * An EVENT_CHECK_DEFAULT signal means check the returned data against the default_data.
185          * An EVENT_CHECK_INITIAL signal means check the returned data against the initial_data.
186          * An EVENT_ERROR signal means the test isn't going to work, exit the event loop.
187          * An EVENT_APPLY_DATA signal means load the test data (after checks) */
188
189         if (outcome & EVENT_ERROR) {
190             trace("Test %s, Stage %u in error state, aborting\n", test[i].test_name, j);
191             break;
192
193         } else if (outcome & EVENT_CHECK_TEST || outcome & EVENT_CHECK_DEFAULT || outcome & EVENT_CHECK_INITIAL) {
194
195             for (i=0; i < ntests; i++) {
196
197                 memcpy(test[i].return_data, test[i].poison_data, test[i].data_size);
198                 test[i].get_handler(device, &test[i], test[i].return_data);
199
200                 if ((outcome & EVENT_CHECK_TEST) &&
201                     memcmp(test[i].test_data_out, test[i].return_data, test[i].data_size)) {
202
203                     ok(FALSE, "Test %s, Stage %u: change applied, but returned data does not "
204                         "match test data [csize=%u]\n", test[i].test_name, j, test[i].data_size);
205
206                     if (test[i].print_handler) {
207                         trace("Returned data was:\n");
208                         test[i].print_handler(test[i].return_data);
209                         trace("Test data was:\n");
210                         test[i].print_handler(test[i].test_data_out);
211                     }
212                 }
213
214                 else if ((outcome & EVENT_CHECK_DEFAULT) &&
215                     memcmp(test[i].default_data, test[i].return_data, test[i].data_size)) {
216
217                     ok (FALSE, "Test %s, Stage %u: change aborted, but returned data does not "
218                          "match default data [csize=%u]\n", test[i].test_name, j, test[i].data_size);
219
220                     if (test[i].print_handler) {
221                         trace("Returned data was:\n");
222                         test[i].print_handler(test[i].return_data);
223                         trace("Default data was:\n");
224                         test[i].print_handler(test[i].default_data);
225                     }
226                 }
227
228                 else if ((outcome & EVENT_CHECK_INITIAL) &&
229                     memcmp(test[i].initial_data, test[i].return_data, test[i].data_size)) {
230
231                     ok (FALSE, "Test %s, Stage %u: returned data does not "
232                          "match initial data [csize=%u]\n", test[i].test_name, j, test[i].data_size);
233
234                     if (test[i].print_handler) {
235                         trace("Returned data was:\n");
236                         test[i].print_handler(test[i].return_data);
237                         trace("Initial data was:\n");
238                         test[i].print_handler(test[i].initial_data);
239                     }
240                 }
241             }
242         }
243
244         if (outcome & EVENT_APPLY_DATA) {
245             for (i=0; i < ntests; i++)
246                 test[i].set_handler(device, &test[i], test[i].test_data_in);
247         }
248      }
249
250      /* Attempt to reset any changes made */
251      for (i=0; i < ntests; i++)
252          test[i].set_handler(device, &test[i], test[i].default_data);
253 }
254
255 typedef struct event_data {
256     IDirect3DStateBlock9* stateblock;
257     IDirect3DSurface9* original_render_target;
258 } event_data;
259
260 static int switch_render_target(
261     IDirect3DDevice9* device,
262     void* data) {
263   
264     HRESULT hret;
265     D3DPRESENT_PARAMETERS present_parameters;
266     event_data* edata = (event_data*) data;
267     IDirect3DSwapChain9* swapchain = NULL;
268     IDirect3DSurface9* backbuffer = NULL;
269
270     /* Parameters for new swapchain */
271     ZeroMemory(&present_parameters, sizeof(present_parameters));
272     present_parameters.Windowed = TRUE;
273     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
274
275     /* Create new swapchain */
276     hret = IDirect3DDevice9_CreateAdditionalSwapChain(device, &present_parameters, &swapchain);
277     ok (hret == D3D_OK, "CreateAdditionalSwapChain returned %#x.\n", hret);
278     if (hret != D3D_OK) goto error;
279
280     /* Get its backbuffer */
281     hret = IDirect3DSwapChain9_GetBackBuffer(swapchain, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
282     ok (hret == D3D_OK, "GetBackBuffer returned %#x.\n", hret);
283     if (hret != D3D_OK) goto error;
284
285     /* Save the current render target */
286     hret = IDirect3DDevice9_GetRenderTarget(device, 0, &edata->original_render_target); 
287     ok (hret == D3D_OK, "GetRenderTarget returned %#x.\n", hret);
288     if (hret != D3D_OK) goto error;
289
290     /* Set the new swapchain's backbuffer as a render target */
291     hret = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
292     ok (hret == D3D_OK, "SetRenderTarget returned %#x.\n", hret);
293     if (hret != D3D_OK) goto error;
294
295     IUnknown_Release(backbuffer);
296     IUnknown_Release(swapchain);
297     return EVENT_OK;
298
299     error:
300     if (backbuffer) IUnknown_Release(backbuffer);
301     if (swapchain) IUnknown_Release(swapchain);
302     return EVENT_ERROR;
303 }
304
305 static int revert_render_target( 
306     IDirect3DDevice9* device,
307     void* data) {
308
309     HRESULT hret;
310     event_data* edata = (event_data*) data;
311    
312     /* Reset the old render target */
313     hret = IDirect3DDevice9_SetRenderTarget(device, 0, edata->original_render_target);
314     ok (hret == D3D_OK, "SetRenderTarget returned %#x.\n", hret);
315     if (hret != D3D_OK) {
316         IUnknown_Release(edata->original_render_target);
317         return EVENT_ERROR;
318     }
319
320     IUnknown_Release(edata->original_render_target);
321     return EVENT_OK;
322 }
323
324 static int begin_stateblock(
325     IDirect3DDevice9* device,
326     void* data) {
327
328     HRESULT hret;
329
330     data = NULL;
331     hret = IDirect3DDevice9_BeginStateBlock(device);
332     ok(hret == D3D_OK, "BeginStateBlock returned %#x.\n", hret);
333     if (hret != D3D_OK) return EVENT_ERROR;
334     return EVENT_OK;
335 }
336
337 static int end_stateblock(
338     IDirect3DDevice9* device,
339     void* data) {
340
341     HRESULT hret;
342     event_data* edata = (event_data*) data;
343
344     hret = IDirect3DDevice9_EndStateBlock(device, &edata->stateblock);
345     ok(hret == D3D_OK, "EndStateBlock returned %#x.\n", hret);
346     if (hret != D3D_OK) return EVENT_ERROR;
347     return EVENT_OK;
348 }
349
350 static int abort_stateblock(
351     IDirect3DDevice9* device,
352     void* data) {
353
354     event_data* edata = (event_data*) data;
355
356     IUnknown_Release(edata->stateblock);
357     return EVENT_OK;
358 }
359
360 static int apply_stateblock(
361     IDirect3DDevice9* device,
362     void* data) {
363
364     event_data* edata = (event_data*) data;
365     HRESULT hret;
366
367     hret = IDirect3DStateBlock9_Apply(edata->stateblock);
368     ok(hret == D3D_OK, "Apply returned %#x.\n", hret);
369     if (hret != D3D_OK) {
370         IUnknown_Release(edata->stateblock);
371         return EVENT_ERROR;
372     }
373
374     IUnknown_Release(edata->stateblock);
375     return EVENT_OK;
376 }
377
378 static int capture_stateblock(
379     IDirect3DDevice9* device,
380     void* data) {
381
382     HRESULT hret;
383     event_data* edata = (event_data*) data;
384
385     hret = IDirect3DStateBlock9_Capture(edata->stateblock);
386     ok(hret == D3D_OK, "Capture returned %#x.\n", hret);
387     if (hret != D3D_OK)
388         return EVENT_ERROR;
389
390     return EVENT_OK;
391 }
392
393 static void execute_test_chain_all(
394     IDirect3DDevice9* device,
395     state_test* test,
396     unsigned int ntests) {
397
398     unsigned int i;
399     event_data arg;
400
401     event read_events[] = {
402         { NULL, EVENT_CHECK_INITIAL }
403     };
404
405     event write_read_events[] = {
406         { NULL, EVENT_APPLY_DATA },
407         { NULL, EVENT_CHECK_TEST }
408     };
409
410     event abort_stateblock_events[] = {
411         { begin_stateblock, EVENT_APPLY_DATA },
412         { end_stateblock, EVENT_OK },
413         { abort_stateblock, EVENT_CHECK_DEFAULT }
414     };
415
416     event apply_stateblock_events[] = {
417         { begin_stateblock, EVENT_APPLY_DATA },
418         { end_stateblock, EVENT_OK },
419         { apply_stateblock, EVENT_CHECK_TEST }
420     };
421
422     event capture_reapply_stateblock_events[] = {
423           { begin_stateblock, EVENT_APPLY_DATA },
424           { end_stateblock, EVENT_OK },
425           { capture_stateblock, EVENT_CHECK_DEFAULT | EVENT_APPLY_DATA },
426           { apply_stateblock, EVENT_CHECK_DEFAULT }
427     };
428
429     event rendertarget_switch_events[] = {
430           { NULL, EVENT_APPLY_DATA },
431           { switch_render_target, EVENT_CHECK_TEST },
432           { revert_render_target, EVENT_OK } 
433     };
434
435     event rendertarget_stateblock_events[] = {
436           { begin_stateblock, EVENT_APPLY_DATA },
437           { switch_render_target, EVENT_CHECK_DEFAULT },
438           { end_stateblock, EVENT_OK },
439           { revert_render_target, EVENT_OK },
440           { apply_stateblock, EVENT_CHECK_TEST }
441     };
442
443     /* Setup each test for execution */
444     for (i=0; i < ntests; i++) {
445         if (test[i].setup_handler(&test[i]) != D3D_OK) {
446             ok(FALSE, "Test \"%s\" failed setup, aborting\n", test[i].test_name);
447             return;
448         }
449     }
450
451     trace("Running initial read state tests\n");
452     execute_test_chain(device, test, ntests, read_events, 1, NULL);
453
454     trace("Running write-read state tests\n");
455     execute_test_chain(device, test, ntests, write_read_events, 2, NULL);
456
457     trace("Running stateblock abort state tests\n");
458     execute_test_chain(device, test, ntests, abort_stateblock_events, 3, &arg);
459
460     trace("Running stateblock apply state tests\n");
461     execute_test_chain(device, test, ntests, apply_stateblock_events, 3, &arg);
462
463     trace("Running stateblock capture/reapply state tests\n");
464     execute_test_chain(device, test, ntests, capture_reapply_stateblock_events, 4, &arg);
465   
466     trace("Running rendertarget switch state tests\n");
467     execute_test_chain(device, test, ntests, rendertarget_switch_events, 3, &arg);
468
469     trace("Running stateblock apply over rendertarget switch interrupt tests\n");
470     execute_test_chain(device, test, ntests, rendertarget_stateblock_events, 5, &arg);
471
472     /* Cleanup resources */
473     for (i=0; i < ntests; i++)
474         test[i].teardown_handler(&test[i]);
475 }
476
477 /* =================== State test: Pixel and Vertex Shader constants ============ */
478
479 typedef struct shader_constant_data {
480     int int_constant[4];     /* 1x4 integer constant */
481     float float_constant[4]; /* 1x4 float constant */
482     BOOL bool_constant[4];   /* 4x1 boolean constants */
483 } shader_constant_data;
484
485 typedef struct shader_constant_arg {
486     unsigned int idx;
487     BOOL pshader;
488 } shader_constant_arg;
489
490 typedef struct shader_constant_context {
491     shader_constant_data return_data_buffer;
492 } shader_constant_context;
493
494 static void shader_constant_print_handler(
495     const void* data) {
496
497     const shader_constant_data* scdata = data;
498
499     trace("Integer constant = { %#x, %#x, %#x, %#x }\n",
500         scdata->int_constant[0], scdata->int_constant[1],
501         scdata->int_constant[2], scdata->int_constant[3]);
502
503     trace("Float constant = { %f, %f, %f, %f }\n",
504         scdata->float_constant[0], scdata->float_constant[1],
505         scdata->float_constant[2], scdata->float_constant[3]);
506
507     trace("Boolean constants = [ %#x, %#x, %#x, %#x ]\n",
508         scdata->bool_constant[0], scdata->bool_constant[1],
509         scdata->bool_constant[2], scdata->bool_constant[3]);
510 }
511
512 static void shader_constant_set_handler(
513     IDirect3DDevice9* device, const state_test* test, const void* data) {
514
515     HRESULT hret;
516     const shader_constant_data* scdata = data;
517     const shader_constant_arg* scarg = test->test_arg;
518     unsigned int index = scarg->idx;
519
520     if (!scarg->pshader) {
521         hret = IDirect3DDevice9_SetVertexShaderConstantI(device, index, scdata->int_constant, 1);
522         ok(hret == D3D_OK, "SetVertexShaderConstantI returned %#x.\n", hret);
523         hret = IDirect3DDevice9_SetVertexShaderConstantF(device, index, scdata->float_constant, 1);
524         ok(hret == D3D_OK, "SetVertexShaderConstantF returned %#x.\n", hret);
525         hret = IDirect3DDevice9_SetVertexShaderConstantB(device, index, scdata->bool_constant, 4);
526         ok(hret == D3D_OK, "SetVertexShaderConstantB returned %#x.\n", hret);
527
528     } else {
529         hret = IDirect3DDevice9_SetPixelShaderConstantI(device, index, scdata->int_constant, 1);
530         ok(hret == D3D_OK, "SetPixelShaderConstantI returned %#x.\n", hret);
531         hret = IDirect3DDevice9_SetPixelShaderConstantF(device, index, scdata->float_constant, 1);
532         ok(hret == D3D_OK, "SetPixelShaderConstantF returned %#x.\n", hret);
533         hret = IDirect3DDevice9_SetPixelShaderConstantB(device, index, scdata->bool_constant, 4);
534         ok(hret == D3D_OK, "SetPixelShaderConstantB returned %#x.\n", hret);
535     }
536 }
537
538 static void shader_constant_get_handler(
539     IDirect3DDevice9* device, const state_test* test, void* data) {
540
541     HRESULT hret;
542     shader_constant_data* scdata = (shader_constant_data*) data;
543     const shader_constant_arg* scarg = test->test_arg;
544     unsigned int index = scarg->idx;
545
546     if (!scarg->pshader) {
547         hret = IDirect3DDevice9_GetVertexShaderConstantI(device, index, scdata->int_constant, 1);
548         ok(hret == D3D_OK, "GetVertexShaderConstantI returned %#x.\n", hret);
549         hret = IDirect3DDevice9_GetVertexShaderConstantF(device, index, scdata->float_constant, 1);
550         ok(hret == D3D_OK, "GetVertexShaderConstantF returned %#x.\n", hret);
551         hret = IDirect3DDevice9_GetVertexShaderConstantB(device, index, scdata->bool_constant, 4);
552         ok(hret == D3D_OK, "GetVertexShaderConstantB returned %#x.\n", hret);
553
554     } else {
555         hret = IDirect3DDevice9_GetPixelShaderConstantI(device, index, scdata->int_constant, 1);
556         ok(hret == D3D_OK, "GetPixelShaderConstantI returned %#x.\n", hret);
557         hret = IDirect3DDevice9_GetPixelShaderConstantF(device, index, scdata->float_constant, 1);
558         ok(hret == D3D_OK, "GetPixelShaderConstantF returned %#x.\n", hret);
559         hret = IDirect3DDevice9_GetPixelShaderConstantB(device, index, scdata->bool_constant, 4);
560         ok(hret == D3D_OK, "GetPixelShaderConstantB returned %#x.\n", hret);
561     }
562 }
563
564 static const shader_constant_data shader_constant_poison_data = {
565     { 0x1337c0de, 0x1337c0de, 0x1337c0de, 0x1337c0de },
566     { 1.0f, 2.0f, 3.0f, 4.0f },
567     { FALSE, TRUE, FALSE, TRUE }
568 };
569
570 static const shader_constant_data shader_constant_default_data = {
571         { 0, 0, 0, 0 }, { 0.0f, 0.0f, 0.0f, 0.0f }, { 0, 0, 0, 0 }
572 };
573
574 static const shader_constant_data shader_constant_test_data = {
575     { 0xdead0000, 0xdead0001, 0xdead0002, 0xdead0003 },
576     { 0.0f, 0.0f, 0.0f, 0.0f },
577     { TRUE, FALSE, FALSE, TRUE }
578 };
579
580 static HRESULT shader_constant_setup_handler(
581     state_test* test) {
582
583     shader_constant_context *ctx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(shader_constant_context));
584     if (ctx == NULL) return E_FAIL;
585     test->test_context = ctx;
586      
587     test->return_data = &ctx->return_data_buffer;
588     test->test_data_in = &shader_constant_test_data;
589     test->test_data_out = &shader_constant_test_data;
590     test->default_data = &shader_constant_default_data;
591     test->initial_data = &shader_constant_default_data;
592     test->poison_data = &shader_constant_poison_data;
593
594     test->data_size = sizeof(shader_constant_data);
595     
596     return D3D_OK;
597 }
598
599 static void shader_constant_teardown_handler(
600     state_test* test) {
601     
602     HeapFree(GetProcessHeap(), 0, test->test_context);
603 }
604
605 static void shader_constants_queue_test(
606     state_test* test,
607     const shader_constant_arg* test_arg) {
608
609     test->setup_handler = shader_constant_setup_handler;
610     test->teardown_handler = shader_constant_teardown_handler;
611     test->set_handler = shader_constant_set_handler;
612     test->get_handler = shader_constant_get_handler;
613     test->print_handler = shader_constant_print_handler;
614     test->test_name = test_arg->pshader? "set_get_pshader_constants": "set_get_vshader_constants";
615     test->test_arg = test_arg;
616 }
617
618 /* =================== State test: Lights ===================================== */
619
620 typedef struct light_data {
621     D3DLIGHT9 light;
622     BOOL enabled;
623     HRESULT get_light_result;
624     HRESULT get_enabled_result;
625 } light_data;
626
627 typedef struct light_arg {
628     unsigned int idx;
629 } light_arg;
630
631 typedef struct light_context {
632     light_data return_data_buffer;
633 } light_context;
634
635 static void light_print_handler(
636     const void* data) {
637
638     const light_data* ldata = data;
639
640     trace("Get Light return value: %#x\n", ldata->get_light_result);
641     trace("Get Light enable return value: %#x\n", ldata->get_enabled_result);
642
643     trace("Light Enabled = %u\n", ldata->enabled);
644     trace("Light Type = %u\n", ldata->light.Type);
645     trace("Light Diffuse = { %f, %f, %f, %f }\n",
646         ldata->light.Diffuse.r, ldata->light.Diffuse.g,
647         ldata->light.Diffuse.b, ldata->light.Diffuse.a);
648     trace("Light Specular = { %f, %f, %f, %f}\n",
649         ldata->light.Specular.r, ldata->light.Specular.g,
650         ldata->light.Specular.b, ldata->light.Specular.a);
651     trace("Light Ambient = { %f, %f, %f, %f }\n",
652         ldata->light.Ambient.r, ldata->light.Ambient.g,
653         ldata->light.Ambient.b, ldata->light.Ambient.a);
654     trace("Light Position = { %f, %f, %f }\n",
655         ldata->light.Position.x, ldata->light.Position.y, ldata->light.Position.z);
656     trace("Light Direction = { %f, %f, %f }\n",
657         ldata->light.Direction.x, ldata->light.Direction.y, ldata->light.Direction.z);
658     trace("Light Range = %f\n", ldata->light.Range);
659     trace("Light Fallof = %f\n", ldata->light.Falloff);
660     trace("Light Attenuation0 = %f\n", ldata->light.Attenuation0);
661     trace("Light Attenuation1 = %f\n", ldata->light.Attenuation1);
662     trace("Light Attenuation2 = %f\n", ldata->light.Attenuation2);
663     trace("Light Theta = %f\n", ldata->light.Theta);
664     trace("Light Phi = %f\n", ldata->light.Phi);
665 }
666
667 static void light_set_handler(
668     IDirect3DDevice9* device, const state_test* test, const void* data) {
669
670     HRESULT hret;
671     const light_data* ldata = data;
672     const light_arg* larg = test->test_arg;
673     unsigned int index = larg->idx;
674
675     hret = IDirect3DDevice9_SetLight(device, index, &ldata->light);
676     ok(hret == D3D_OK, "SetLight returned %#x.\n", hret);
677
678     hret = IDirect3DDevice9_LightEnable(device, index, ldata->enabled);
679     ok(hret == D3D_OK, "SetLightEnable returned %#x.\n", hret);
680 }
681
682 static void light_get_handler(
683     IDirect3DDevice9* device, const state_test* test, void* data) {
684
685     HRESULT hret;
686     light_data* ldata = data;
687     const light_arg* larg = test->test_arg;
688     unsigned int index = larg->idx;
689
690     hret = IDirect3DDevice9_GetLightEnable(device, index, &ldata->enabled);
691     ldata->get_enabled_result = hret;
692
693     hret = IDirect3DDevice9_GetLight(device, index, &ldata->light);
694     ldata->get_light_result = hret;
695 }
696
697 static const light_data light_poison_data = 
698     { { 0x1337c0de,
699         { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 },
700         { 3.3, 4.4, 5.5 }, { 6.6, 7.7, 8.8 },
701         12.12, 13.13, 14.14, 15.15, 16.16, 17.17, 18.18 }, 1, 0x1337c0de, 0x1337c0de };
702
703 static const light_data light_default_data =
704     { { D3DLIGHT_DIRECTIONAL,
705         { 1.0, 1.0, 1.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 },
706         { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 1.0 },
707         0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }, 0, D3D_OK, D3D_OK };
708
709 /* This is used for the initial read state (before a write causes side effects)
710  * The proper return status is D3DERR_INVALIDCALL */
711 static const light_data light_initial_data =
712     { { 0x1337c0de,
713         { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 },
714         { 3.3, 4.4, 5.5 }, { 6.6, 7.7, 8.8 },
715         12.12, 13.13, 14.14, 15.15, 16.16, 17.17, 18.18 }, 1, D3DERR_INVALIDCALL, D3DERR_INVALIDCALL };
716
717 static const light_data light_test_data_in =
718     { { 1,
719         { 2.0, 2.0, 2.0, 2.0 }, { 3.0, 3.0, 3.0, 3.0 }, { 4.0, 4.0, 4.0, 4.0 },
720         { 5.0, 5.0, 5.0 }, { 6.0, 6.0, 6.0 },
721         7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 }, 1, D3D_OK, D3D_OK};
722
723 /* SetLight will use 128 as the "enabled" value */
724 static const light_data light_test_data_out = 
725     { { 1,
726         { 2.0, 2.0, 2.0, 2.0 }, { 3.0, 3.0, 3.0, 3.0 }, { 4.0, 4.0, 4.0, 4.0 },
727         { 5.0, 5.0, 5.0 }, { 6.0, 6.0, 6.0 },
728         7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 }, 128, D3D_OK, D3D_OK};
729
730 static HRESULT light_setup_handler(
731     state_test* test) {
732      
733     light_context *ctx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(light_context));
734     if (ctx == NULL) return E_FAIL;
735     test->test_context = ctx;
736  
737     test->return_data = &ctx->return_data_buffer;
738     test->test_data_in = &light_test_data_in;
739     test->test_data_out = &light_test_data_out;
740     test->default_data = &light_default_data;
741     test->initial_data = &light_initial_data;
742     test->poison_data = &light_poison_data;
743
744     test->data_size = sizeof(light_data);
745     
746     return D3D_OK;
747 }
748
749 static void light_teardown_handler(
750     state_test* test) {
751     
752     HeapFree(GetProcessHeap(), 0, test->test_context);
753 }
754
755 static void lights_queue_test(
756     state_test* test,
757     const light_arg* test_arg) {
758
759     test->setup_handler = light_setup_handler;
760     test->teardown_handler = light_teardown_handler;
761     test->set_handler = light_set_handler;
762     test->get_handler = light_get_handler;
763     test->print_handler = light_print_handler;
764     test->test_name = "set_get_light";
765     test->test_arg = test_arg;
766 }
767
768 /* =================== State test: Transforms ===================================== */
769
770 typedef struct transform_data {
771
772     D3DMATRIX view;
773     D3DMATRIX projection;
774     D3DMATRIX texture0;
775     D3DMATRIX texture7;
776     D3DMATRIX world0;
777     D3DMATRIX world255;
778
779 } transform_data;
780
781 typedef struct transform_context {
782     transform_data return_data_buffer;
783 } transform_context;
784
785 static inline void print_matrix(
786     const char* name, const D3DMATRIX* matrix) {
787
788     trace("%s Matrix = {\n", name);
789     trace("    %f %f %f %f\n", matrix->m[0][0], matrix->m[1][0], matrix->m[2][0], matrix->m[3][0]);
790     trace("    %f %f %f %f\n", matrix->m[0][1], matrix->m[1][1], matrix->m[2][1], matrix->m[3][1]);
791     trace("    %f %f %f %f\n", matrix->m[0][2], matrix->m[1][2], matrix->m[2][2], matrix->m[3][2]);
792     trace("    %f %f %f %f\n", matrix->m[0][3], matrix->m[1][3], matrix->m[2][3], matrix->m[3][3]);
793     trace("}\n");
794 }
795
796 static void transform_print_handler(
797     const void* data) {
798
799     const transform_data* tdata = data;
800
801     print_matrix("View", &tdata->view);
802     print_matrix("Projection", &tdata->projection);
803     print_matrix("Texture0", &tdata->texture0);
804     print_matrix("Texture7", &tdata->texture7);
805     print_matrix("World0", &tdata->world0);
806     print_matrix("World255", &tdata->world255);
807 }
808
809 static void transform_set_handler(
810     IDirect3DDevice9* device, const state_test* test, const void* data) {
811
812     HRESULT hret;
813     const transform_data* tdata = data;
814
815     hret = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, &tdata->view);
816     ok(hret == D3D_OK, "SetTransform returned %#x.\n", hret);
817
818     hret = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &tdata->projection);
819     ok(hret == D3D_OK, "SetTransform returned %#x.\n", hret);
820
821     hret = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, &tdata->texture0);
822     ok(hret == D3D_OK, "SetTransform returned %#x.\n", hret);
823
824     hret = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0 + texture_stages - 1, &tdata->texture7);
825     ok(hret == D3D_OK, "SetTransform returned %#x.\n", hret);
826
827     hret = IDirect3DDevice9_SetTransform(device, D3DTS_WORLD, &tdata->world0);
828     ok(hret == D3D_OK, "SetTransform returned %#x.\n", hret);
829
830     hret = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(255), &tdata->world255);
831     ok(hret == D3D_OK, "SetTransform returned %#x.\n", hret);
832 }
833
834 static void transform_get_handler(
835     IDirect3DDevice9* device, const state_test* test, void* data) {
836
837     HRESULT hret;
838     transform_data* tdata = (transform_data*) data;
839
840     hret = IDirect3DDevice9_GetTransform(device, D3DTS_VIEW, &tdata->view);
841     ok(hret == D3D_OK, "GetTransform returned %#x.\n", hret);
842
843     hret = IDirect3DDevice9_GetTransform(device, D3DTS_PROJECTION, &tdata->projection);
844     ok(hret == D3D_OK, "GetTransform returned %#x.\n", hret);
845
846     hret = IDirect3DDevice9_GetTransform(device, D3DTS_TEXTURE0, &tdata->texture0);
847     ok(hret == D3D_OK, "GetTransform returned %#x.\n", hret);
848
849     hret = IDirect3DDevice9_GetTransform(device, D3DTS_TEXTURE0 + texture_stages - 1, &tdata->texture7);
850     ok(hret == D3D_OK, "GetTransform returned %#x.\n", hret);
851
852     hret = IDirect3DDevice9_GetTransform(device, D3DTS_WORLD, &tdata->world0);
853     ok(hret == D3D_OK, "GetTransform returned %#x.\n", hret);
854
855     hret = IDirect3DDevice9_GetTransform(device, D3DTS_WORLDMATRIX(255), &tdata->world255);
856     ok(hret == D3D_OK, "GetTransform returned %#x.\n", hret);
857 }
858
859 static const transform_data transform_default_data = {
860       { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
861       { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
862       { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
863       { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
864       { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
865       { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } }
866 };
867
868 static const transform_data transform_poison_data = {
869       { { { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
870         9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 } } },
871
872       { { { 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0,
873         25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0 } } },
874
875       { { { 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0,
876         41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0 } } },
877
878       { { { 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0,
879         57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0, 64.0 } } },
880
881       { { { 64.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 72.0,
882         73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0 } } },
883
884       { { { 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0,
885         89.0, 90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0} } },
886 };
887
888 static const transform_data transform_test_data = {
889       { { { 1.2, 3.4, -5.6, 7.2, 10.11, -12.13, 14.15, -1.5,
890         23.56, 12.89, 44.56, -1.0, 2.3, 0.0, 4.4, 5.5 } } },
891
892       { { { 9.2, 38.7, -6.6, 7.2, 10.11, -12.13, 77.15, -1.5,
893         23.56, 12.89, 14.56, -1.0, 12.3, 0.0, 4.4, 5.5 } } },
894
895       { { { 10.2, 3.4, 0.6, 7.2, 10.11, -12.13, 14.15, -1.5,
896         23.54, 12.9, 44.56, -1.0, 2.3, 0.0, 4.4, 5.5 } } },
897
898       { { { 1.2, 3.4, -5.6, 7.2, 10.11, -12.13, -14.5, -1.5,
899         2.56, 12.89, 23.56, -1.0, 112.3, 0.0, 4.4, 2.5 } } },
900
901       { { { 1.2, 31.41, 58.6, 7.2, 10.11, -12.13, -14.5, -1.5,
902         2.56, 12.89, 11.56, -1.0, 112.3, 0.0, 44.4, 2.5 } } },
903
904       { { { 1.20, 3.4, -5.6, 7.0, 10.11, -12.156, -14.5, -1.5,
905         2.56, 1.829, 23.6, -1.0, 112.3, 0.0, 41.4, 2.5 } } },
906 };
907
908 static HRESULT transform_setup_handler(
909     state_test* test) {
910
911     transform_context *ctx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(transform_context));
912     if (ctx == NULL) return E_FAIL;
913     test->test_context = ctx;
914
915     test->return_data = &ctx->return_data_buffer;
916     test->test_data_in = &transform_test_data;
917     test->test_data_out = &transform_test_data;
918     test->default_data = &transform_default_data;
919     test->initial_data = &transform_default_data;
920     test->poison_data = &transform_poison_data;
921
922     test->data_size = sizeof(transform_data);
923
924     return D3D_OK;
925 }
926
927 static void transform_teardown_handler(
928     state_test* test) {
929     
930     HeapFree(GetProcessHeap(), 0, test->test_context);
931 }
932
933 static void transform_queue_test(
934     state_test* test) {
935
936     test->setup_handler = transform_setup_handler;
937     test->teardown_handler = transform_teardown_handler;
938     test->set_handler = transform_set_handler;
939     test->get_handler = transform_get_handler;
940     test->print_handler = transform_print_handler;
941     test->test_name = "set_get_transforms";
942     test->test_arg = NULL;
943 }
944
945 /* =================== State test: Render States ===================================== */
946
947 #define D3D9_RENDER_STATES 102
948 const D3DRENDERSTATETYPE render_state_indices[] = {
949
950     D3DRS_ZENABLE,
951     D3DRS_FILLMODE,
952     D3DRS_SHADEMODE,
953     D3DRS_ZWRITEENABLE,
954     D3DRS_ALPHATESTENABLE,
955     D3DRS_LASTPIXEL,
956     D3DRS_SRCBLEND,
957     D3DRS_DESTBLEND,
958     D3DRS_CULLMODE,
959     D3DRS_ZFUNC,
960     D3DRS_ALPHAREF,
961     D3DRS_ALPHAFUNC,
962     D3DRS_DITHERENABLE,
963     D3DRS_ALPHABLENDENABLE,
964     D3DRS_FOGENABLE,
965     D3DRS_SPECULARENABLE,
966     D3DRS_FOGCOLOR,
967     D3DRS_FOGTABLEMODE,
968     D3DRS_FOGSTART,
969     D3DRS_FOGEND,
970     D3DRS_FOGDENSITY,
971     D3DRS_RANGEFOGENABLE,
972     D3DRS_STENCILENABLE,
973     D3DRS_STENCILFAIL,
974     D3DRS_STENCILZFAIL,
975     D3DRS_STENCILPASS,
976     D3DRS_STENCILFUNC,
977     D3DRS_STENCILREF,
978     D3DRS_STENCILMASK,
979     D3DRS_STENCILWRITEMASK,
980     D3DRS_TEXTUREFACTOR,
981     D3DRS_WRAP0,
982     D3DRS_WRAP1,
983     D3DRS_WRAP2,
984     D3DRS_WRAP3,
985     D3DRS_WRAP4,
986     D3DRS_WRAP5,
987     D3DRS_WRAP6,
988     D3DRS_WRAP7,
989     D3DRS_CLIPPING,
990     D3DRS_LIGHTING,
991     D3DRS_AMBIENT,
992     D3DRS_FOGVERTEXMODE,
993     D3DRS_COLORVERTEX,
994     D3DRS_LOCALVIEWER,
995     D3DRS_NORMALIZENORMALS,
996     D3DRS_DIFFUSEMATERIALSOURCE,
997     D3DRS_SPECULARMATERIALSOURCE,
998     D3DRS_AMBIENTMATERIALSOURCE,
999     D3DRS_EMISSIVEMATERIALSOURCE,
1000     D3DRS_VERTEXBLEND,
1001     D3DRS_CLIPPLANEENABLE,
1002 #if 0 /* Driver dependent, increase array size to enable */
1003     D3DRS_POINTSIZE,
1004 #endif
1005     D3DRS_POINTSIZE_MIN,
1006     D3DRS_POINTSPRITEENABLE,
1007     D3DRS_POINTSCALEENABLE,
1008     D3DRS_POINTSCALE_A,
1009     D3DRS_POINTSCALE_B,
1010     D3DRS_POINTSCALE_C,
1011     D3DRS_MULTISAMPLEANTIALIAS,
1012     D3DRS_MULTISAMPLEMASK,
1013     D3DRS_PATCHEDGESTYLE,
1014     D3DRS_DEBUGMONITORTOKEN,
1015     D3DRS_POINTSIZE_MAX,
1016     D3DRS_INDEXEDVERTEXBLENDENABLE,
1017     D3DRS_COLORWRITEENABLE,
1018     D3DRS_TWEENFACTOR,
1019     D3DRS_BLENDOP,
1020     D3DRS_POSITIONDEGREE,
1021     D3DRS_NORMALDEGREE,
1022     D3DRS_SCISSORTESTENABLE,
1023     D3DRS_SLOPESCALEDEPTHBIAS,
1024     D3DRS_ANTIALIASEDLINEENABLE,
1025     D3DRS_MINTESSELLATIONLEVEL,
1026     D3DRS_MAXTESSELLATIONLEVEL,
1027     D3DRS_ADAPTIVETESS_X,
1028     D3DRS_ADAPTIVETESS_Y,
1029     D3DRS_ADAPTIVETESS_Z,
1030     D3DRS_ADAPTIVETESS_W,
1031     D3DRS_ENABLEADAPTIVETESSELLATION,
1032     D3DRS_TWOSIDEDSTENCILMODE,
1033     D3DRS_CCW_STENCILFAIL,
1034     D3DRS_CCW_STENCILZFAIL,
1035     D3DRS_CCW_STENCILPASS,
1036     D3DRS_CCW_STENCILFUNC,
1037     D3DRS_COLORWRITEENABLE1,
1038     D3DRS_COLORWRITEENABLE2,
1039     D3DRS_COLORWRITEENABLE3,
1040     D3DRS_BLENDFACTOR,
1041     D3DRS_SRGBWRITEENABLE,
1042     D3DRS_DEPTHBIAS,
1043     D3DRS_WRAP8,
1044     D3DRS_WRAP9,
1045     D3DRS_WRAP10,
1046     D3DRS_WRAP11,
1047     D3DRS_WRAP12,
1048     D3DRS_WRAP13,
1049     D3DRS_WRAP14,
1050     D3DRS_WRAP15,
1051     D3DRS_SEPARATEALPHABLENDENABLE,
1052     D3DRS_SRCBLENDALPHA,
1053     D3DRS_DESTBLENDALPHA,
1054     D3DRS_BLENDOPALPHA,
1055 };
1056
1057 typedef struct render_state_data {
1058     DWORD states[D3D9_RENDER_STATES];
1059 } render_state_data;
1060
1061 typedef struct render_state_arg {
1062     D3DPRESENT_PARAMETERS* device_pparams;
1063 } render_state_arg;
1064
1065 typedef struct render_state_context {
1066    render_state_data return_data_buffer;
1067    render_state_data default_data_buffer;
1068    render_state_data test_data_buffer;
1069    render_state_data poison_data_buffer;
1070 } render_state_context;
1071
1072 static void render_state_set_handler(
1073     IDirect3DDevice9* device, const state_test* test, const void* data) {
1074
1075     HRESULT hret;
1076     const render_state_data* rsdata = data;
1077     unsigned int i;
1078
1079     for (i = 0; i < D3D9_RENDER_STATES; i++) {
1080         hret = IDirect3DDevice9_SetRenderState(device, render_state_indices[i], rsdata->states[i]);
1081         ok(hret == D3D_OK, "SetRenderState returned %#x.\n", hret);
1082     }
1083 }
1084
1085 static void render_state_get_handler(
1086     IDirect3DDevice9* device, const state_test* test, void* data) {
1087
1088     HRESULT hret;
1089     render_state_data* rsdata = (render_state_data*) data;
1090     unsigned int i = 0;
1091
1092     for (i = 0; i < D3D9_RENDER_STATES; i++) {
1093         hret = IDirect3DDevice9_GetRenderState(device, render_state_indices[i], &rsdata->states[i]);
1094         ok(hret == D3D_OK, "GetRenderState returned %#x.\n", hret);
1095     }
1096 }
1097
1098 static void render_state_print_handler(
1099     const void* data) {
1100
1101     const render_state_data* rsdata = data;
1102
1103     unsigned int i;
1104     for (i = 0; i < D3D9_RENDER_STATES; i++)
1105         trace("Index = %u, Value = %#x\n", i, rsdata->states[i]);
1106 }
1107
1108 static inline DWORD to_dword(float fl) {
1109     return *((DWORD*) &fl);
1110 }
1111
1112 static void render_state_default_data_init(
1113     D3DPRESENT_PARAMETERS* device_pparams,
1114     render_state_data* data) {
1115
1116    unsigned int idx = 0;
1117
1118    data->states[idx++] = device_pparams->EnableAutoDepthStencil?
1119                          D3DZB_TRUE : D3DZB_FALSE;  /* ZENABLE */
1120    data->states[idx++] = D3DFILL_SOLID;         /* FILLMODE */
1121    data->states[idx++] = D3DSHADE_GOURAUD;      /* SHADEMODE */
1122    data->states[idx++] = TRUE;                  /* ZWRITEENABLE */
1123    data->states[idx++] = FALSE;                 /* ALPHATESTENABLE */
1124    data->states[idx++] = TRUE;                  /* LASTPIXEL */
1125    data->states[idx++] = D3DBLEND_ONE;          /* SRCBLEND */
1126    data->states[idx++] = D3DBLEND_ZERO;         /* DESTBLEND */
1127    data->states[idx++] = D3DCULL_CCW;           /* CULLMODE */
1128    data->states[idx++] = D3DCMP_LESSEQUAL;      /* ZFUNC */
1129    data->states[idx++] = 0;                     /* ALPHAREF */
1130    data->states[idx++] = D3DCMP_ALWAYS;         /* ALPHAFUNC */
1131    data->states[idx++] = FALSE;                 /* DITHERENABLE */
1132    data->states[idx++] = FALSE;                 /* ALPHABLENDENABLE */
1133    data->states[idx++] = FALSE;                 /* FOGENABLE */
1134    data->states[idx++] = FALSE;                 /* SPECULARENABLE */
1135    data->states[idx++] = 0;                     /* FOGCOLOR */
1136    data->states[idx++] = D3DFOG_NONE;           /* FOGTABLEMODE */
1137    data->states[idx++] = to_dword(0.0f);        /* FOGSTART */
1138    data->states[idx++] = to_dword(1.0f);        /* FOGEND */
1139    data->states[idx++] = to_dword(1.0f);        /* FOGDENSITY */
1140    data->states[idx++] = FALSE;                 /* RANGEFOGENABLE */
1141    data->states[idx++] = FALSE;                 /* STENCILENABLE */
1142    data->states[idx++] = D3DSTENCILOP_KEEP;     /* STENCILFAIL */
1143    data->states[idx++] = D3DSTENCILOP_KEEP;     /* STENCILZFAIL */
1144    data->states[idx++] = D3DSTENCILOP_KEEP;     /* STENCILPASS */
1145    data->states[idx++] = D3DCMP_ALWAYS;         /* STENCILFUNC */
1146    data->states[idx++] = 0;                     /* STENCILREF */
1147    data->states[idx++] = 0xFFFFFFFF;            /* STENCILMASK */
1148    data->states[idx++] = 0xFFFFFFFF;            /* STENCILWRITEMASK */
1149    data->states[idx++] = 0xFFFFFFFF;            /* TEXTUREFACTOR */
1150    data->states[idx++] = 0;                     /* WRAP 0 */
1151    data->states[idx++] = 0;                     /* WRAP 1 */
1152    data->states[idx++] = 0;                     /* WRAP 2 */
1153    data->states[idx++] = 0;                     /* WRAP 3 */
1154    data->states[idx++] = 0;                     /* WRAP 4 */
1155    data->states[idx++] = 0;                     /* WRAP 5 */
1156    data->states[idx++] = 0;                     /* WRAP 6 */
1157    data->states[idx++] = 0;                     /* WRAP 7 */
1158    data->states[idx++] = TRUE;                  /* CLIPPING */
1159    data->states[idx++] = TRUE;                  /* LIGHTING */
1160    data->states[idx++] = 0;                     /* AMBIENT */
1161    data->states[idx++] = D3DFOG_NONE;           /* FOGVERTEXMODE */
1162    data->states[idx++] = TRUE;                  /* COLORVERTEX */
1163    data->states[idx++] = TRUE;                  /* LOCALVIEWER */
1164    data->states[idx++] = FALSE;                 /* NORMALIZENORMALS */
1165    data->states[idx++] = D3DMCS_COLOR1;         /* DIFFUSEMATERIALSOURCE */
1166    data->states[idx++] = D3DMCS_COLOR2;         /* SPECULARMATERIALSOURCE */
1167    data->states[idx++] = D3DMCS_MATERIAL;       /* AMBIENTMATERIALSOURCE */
1168    data->states[idx++] = D3DMCS_MATERIAL;       /* EMISSIVEMATERIALSOURCE */
1169    data->states[idx++] = D3DVBF_DISABLE;        /* VERTEXBLEND */
1170    data->states[idx++] = 0;                     /* CLIPPLANEENABLE */
1171 #if 0 /* Driver dependent, increase array size to enable */
1172    data->states[idx++] = to_dword(1.0f);       /* POINTSIZE */
1173 #endif
1174    data->states[idx++] = to_dword(1.0f);        /* POINTSIZEMIN */
1175    data->states[idx++] = FALSE;                 /* POINTSPRITEENABLE */
1176    data->states[idx++] = FALSE;                 /* POINTSCALEENABLE */
1177    data->states[idx++] = to_dword(1.0f);        /* POINTSCALE_A */
1178    data->states[idx++] = to_dword(0.0f);        /* POINTSCALE_B */
1179    data->states[idx++] = to_dword(0.0f);        /* POINTSCALE_C */
1180    data->states[idx++] = TRUE;                  /* MULTISAMPLEANTIALIAS */
1181    data->states[idx++] = 0xFFFFFFFF;            /* MULTISAMPLEMASK */
1182    data->states[idx++] = D3DPATCHEDGE_DISCRETE; /* PATCHEDGESTYLE */ 
1183    data->states[idx++] = 0xbaadcafe;            /* DEBUGMONITORTOKEN */
1184    data->states[idx++] = to_dword(64.0f);       /* POINTSIZE_MAX */
1185    data->states[idx++] = FALSE;                 /* INDEXEDVERTEXBLENDENABLE */
1186    data->states[idx++] = 0x0000000F;            /* COLORWRITEENABLE */
1187    data->states[idx++] = to_dword(0.0f);        /* TWEENFACTOR */
1188    data->states[idx++] = D3DBLENDOP_ADD;        /* BLENDOP */
1189    data->states[idx++] = D3DDEGREE_CUBIC;       /* POSITIONDEGREE */
1190    data->states[idx++] = D3DDEGREE_LINEAR;      /* NORMALDEGREE */
1191    data->states[idx++] = FALSE;                 /* SCISSORTESTENABLE */
1192    data->states[idx++] = to_dword(0.0f);        /* SLOPESCALEDEPTHBIAS */
1193    data->states[idx++] = FALSE;                 /* ANTIALIASEDLINEENABLE */
1194    data->states[idx++] = to_dword(1.0f);        /* MINTESSELATIONLEVEL */
1195    data->states[idx++] = to_dword(1.0f);        /* MAXTESSELATIONLEVEL */
1196    data->states[idx++] = to_dword(0.0f);        /* ADAPTIVETESS_X */
1197    data->states[idx++] = to_dword(0.0f);        /* ADAPTIVETESS_Y */
1198    data->states[idx++] = to_dword(1.0f);        /* ADAPTIVETESS_Z */
1199    data->states[idx++] = to_dword(0.0f);        /* ADAPTIVETESS_W */
1200    data->states[idx++] = FALSE;                 /* ENABLEADAPTIVETESSELATION */
1201    data->states[idx++] = FALSE;                 /* TWOSIDEDSTENCILMODE */
1202    data->states[idx++] = D3DSTENCILOP_KEEP;     /* CCW_STENCILFAIL */
1203    data->states[idx++] = D3DSTENCILOP_KEEP;     /* CCW_STENCILZFAIL */
1204    data->states[idx++] = D3DSTENCILOP_KEEP;     /* CCW_STENCILPASS */
1205    data->states[idx++] = D3DCMP_ALWAYS;         /* CCW_STENCILFUNC */
1206    data->states[idx++] = 0x0000000F;            /* COLORWRITEENABLE1 */
1207    data->states[idx++] = 0x0000000F;            /* COLORWRITEENABLE2 */
1208    data->states[idx++] = 0x0000000F;            /* COLORWRITEENABLE3 */
1209    data->states[idx++] = 0xFFFFFFFF;            /* BLENDFACTOR */
1210    data->states[idx++] = 0;                     /* SRGBWRITEENABLE */
1211    data->states[idx++] = to_dword(0.0f);        /* DEPTHBIAS */
1212    data->states[idx++] = 0;                     /* WRAP8 */
1213    data->states[idx++] = 0;                     /* WRAP9 */
1214    data->states[idx++] = 0;                     /* WRAP10 */
1215    data->states[idx++] = 0;                     /* WRAP11 */
1216    data->states[idx++] = 0;                     /* WRAP12 */
1217    data->states[idx++] = 0;                     /* WRAP13 */
1218    data->states[idx++] = 0;                     /* WRAP14 */
1219    data->states[idx++] = 0;                     /* WRAP15 */
1220    data->states[idx++] = FALSE;                 /* SEPARATEALPHABLENDENABLE */
1221    data->states[idx++] = D3DBLEND_ONE;          /* SRCBLENDALPHA */
1222    data->states[idx++] = D3DBLEND_ZERO;         /* DESTBLENDALPHA */
1223    data->states[idx++] = TRUE;                  /* BLENDOPALPHA */
1224 }
1225
1226 static void render_state_poison_data_init(
1227     render_state_data* data) {
1228
1229    unsigned int i;
1230    for (i = 0; i < D3D9_RENDER_STATES; i++)
1231        data->states[i] = 0x1337c0de;
1232 }
1233  
1234 static void render_state_test_data_init(
1235     render_state_data* data) {
1236
1237    unsigned int idx = 0;
1238    data->states[idx++] = D3DZB_USEW;            /* ZENABLE */
1239    data->states[idx++] = D3DFILL_WIREFRAME;     /* FILLMODE */
1240    data->states[idx++] = D3DSHADE_PHONG;        /* SHADEMODE */
1241    data->states[idx++] = FALSE;                 /* ZWRITEENABLE */
1242    data->states[idx++] = TRUE;                  /* ALPHATESTENABLE */
1243    data->states[idx++] = FALSE;                 /* LASTPIXEL */
1244    data->states[idx++] = D3DBLEND_SRCALPHASAT;  /* SRCBLEND */
1245    data->states[idx++] = D3DBLEND_INVDESTALPHA; /* DESTBLEND */
1246    data->states[idx++] = D3DCULL_CW;            /* CULLMODE */
1247    data->states[idx++] = D3DCMP_NOTEQUAL;       /* ZFUNC */
1248    data->states[idx++] = 10;                    /* ALPHAREF */
1249    data->states[idx++] = D3DCMP_GREATER;        /* ALPHAFUNC */
1250    data->states[idx++] = TRUE;                  /* DITHERENABLE */
1251    data->states[idx++] = TRUE;                  /* ALPHABLENDENABLE */
1252    data->states[idx++] = TRUE;                  /* FOGENABLE */
1253    data->states[idx++] = TRUE;                  /* SPECULARENABLE */
1254    data->states[idx++] = 255 << 31;             /* FOGCOLOR */
1255    data->states[idx++] = D3DFOG_EXP;            /* FOGTABLEMODE */
1256    data->states[idx++] = to_dword(0.1f);        /* FOGSTART */
1257    data->states[idx++] = to_dword(0.8f);        /* FOGEND */
1258    data->states[idx++] = to_dword(0.5f);        /* FOGDENSITY */
1259    data->states[idx++] = TRUE;                  /* RANGEFOGENABLE */
1260    data->states[idx++] = TRUE;                  /* STENCILENABLE */
1261    data->states[idx++] = D3DSTENCILOP_INCRSAT;  /* STENCILFAIL */
1262    data->states[idx++] = D3DSTENCILOP_REPLACE;  /* STENCILZFAIL */
1263    data->states[idx++] = D3DSTENCILOP_INVERT;   /* STENCILPASS */
1264    data->states[idx++] = D3DCMP_LESS;           /* STENCILFUNC */
1265    data->states[idx++] = 10;                    /* STENCILREF */
1266    data->states[idx++] = 0xFF00FF00;            /* STENCILMASK */
1267    data->states[idx++] = 0x00FF00FF;            /* STENCILWRITEMASK */
1268    data->states[idx++] = 0xF0F0F0F0;            /* TEXTUREFACTOR */
1269    data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_2;                                   /* WRAP 0 */
1270    data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3;                                   /* WRAP 1 */
1271    data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_3;                                   /* WRAP 2 */
1272    data->states[idx++] = D3DWRAPCOORD_3 | D3DWRAPCOORD_0;                                   /* WRAP 4 */
1273    data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2;                  /* WRAP 5 */
1274    data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3 | D3DWRAPCOORD_2;                  /* WRAP 6 */
1275    data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_1 | D3DWRAPCOORD_0;                  /* WRAP 7 */
1276    data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_0 | D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 8 */
1277    data->states[idx++] = FALSE;                 /* CLIPPING */
1278    data->states[idx++] = FALSE;                 /* LIGHTING */
1279    data->states[idx++] = 255 << 16;             /* AMBIENT */
1280    data->states[idx++] = D3DFOG_EXP2;           /* FOGVERTEXMODE */
1281    data->states[idx++] = FALSE;                 /* COLORVERTEX */
1282    data->states[idx++] = FALSE;                 /* LOCALVIEWER */
1283    data->states[idx++] = TRUE;                  /* NORMALIZENORMALS */
1284    data->states[idx++] = D3DMCS_COLOR2;         /* DIFFUSEMATERIALSOURCE */
1285    data->states[idx++] = D3DMCS_MATERIAL;       /* SPECULARMATERIALSOURCE */
1286    data->states[idx++] = D3DMCS_COLOR1;         /* AMBIENTMATERIALSOURCE */
1287    data->states[idx++] = D3DMCS_COLOR2;         /* EMISSIVEMATERIALSOURCE */
1288    data->states[idx++] = D3DVBF_3WEIGHTS;       /* VERTEXBLEND */
1289    data->states[idx++] = 0xf1f1f1f1;            /* CLIPPLANEENABLE */
1290 #if 0 /* Driver dependent, increase array size to enable */
1291    data->states[idx++] = to_dword(32.0f);       /* POINTSIZE */
1292 #endif
1293    data->states[idx++] = to_dword(0.7f);        /* POINTSIZEMIN */
1294    data->states[idx++] = TRUE;                  /* POINTSPRITEENABLE */
1295    data->states[idx++] = TRUE;                  /* POINTSCALEENABLE */
1296    data->states[idx++] = to_dword(0.7f);        /* POINTSCALE_A */
1297    data->states[idx++] = to_dword(0.5f);        /* POINTSCALE_B */
1298    data->states[idx++] = to_dword(0.4f);        /* POINTSCALE_C */
1299    data->states[idx++] = FALSE;                 /* MULTISAMPLEANTIALIAS */
1300    data->states[idx++] = 0xABCDDBCA;            /* MULTISAMPLEMASK */
1301    data->states[idx++] = D3DPATCHEDGE_CONTINUOUS; /* PATCHEDGESTYLE */
1302    data->states[idx++] = D3DDMT_DISABLE;        /* DEBUGMONITORTOKEN */
1303    data->states[idx++] = to_dword(77.0f);       /* POINTSIZE_MAX */
1304    data->states[idx++] = TRUE;                  /* INDEXEDVERTEXBLENDENABLE */
1305    data->states[idx++] = 0x00000009;            /* COLORWRITEENABLE */
1306    data->states[idx++] = to_dword(0.2f);        /* TWEENFACTOR */
1307    data->states[idx++] = D3DBLENDOP_REVSUBTRACT;/* BLENDOP */
1308    data->states[idx++] = D3DDEGREE_LINEAR;      /* POSITIONDEGREE */
1309    data->states[idx++] = D3DDEGREE_CUBIC;       /* NORMALDEGREE */
1310    data->states[idx++] = TRUE;                  /* SCISSORTESTENABLE */
1311    data->states[idx++] = to_dword(0.33f);       /* SLOPESCALEDEPTHBIAS */
1312    data->states[idx++] = TRUE;                  /* ANTIALIASEDLINEENABLE */
1313    data->states[idx++] = to_dword(0.8f);        /* MINTESSELATIONLEVEL */
1314    data->states[idx++] = to_dword(0.8f);        /* MAXTESSELATIONLEVEL */
1315    data->states[idx++] = to_dword(0.2f);        /* ADAPTIVETESS_X */
1316    data->states[idx++] = to_dword(0.3f);        /* ADAPTIVETESS_Y */
1317    data->states[idx++] = to_dword(0.6f);        /* ADAPTIVETESS_Z */
1318    data->states[idx++] = to_dword(0.4f);        /* ADAPTIVETESS_W */
1319    data->states[idx++] = TRUE;                  /* ENABLEADAPTIVETESSELATION */
1320    data->states[idx++] = TRUE;                  /* TWOSIDEDSTENCILMODE */
1321    data->states[idx++] = D3DSTENCILOP_ZERO;     /* CCW_STENCILFAIL */
1322    data->states[idx++] = D3DSTENCILOP_DECR;     /* CCW_STENCILZFAIL */
1323    data->states[idx++] = D3DSTENCILOP_INCR;     /* CCW_STENCILPASS */
1324    data->states[idx++] = D3DCMP_ALWAYS;         /* CCW_STENCILFUNC */
1325    data->states[idx++] = 0x00000007;            /* COLORWRITEENABLE1 */
1326    data->states[idx++] = 0x00000008;            /* COLORWRITEENABLE2 */
1327    data->states[idx++] = 0x00000004;            /* COLORWRITEENABLE3 */
1328    data->states[idx++] = 0xF0F1F2F3;            /* BLENDFACTOR */
1329    data->states[idx++] = 1;                     /* SRGBWRITEENABLE */
1330    data->states[idx++] = to_dword(0.3f);        /* DEPTHBIAS */
1331    data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_2;                                   /* WRAP 8 */
1332    data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3;                                   /* WRAP 9 */
1333    data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_3;                                   /* WRAP 10 */
1334    data->states[idx++] = D3DWRAPCOORD_3 | D3DWRAPCOORD_0;                                   /* WRAP 11 */
1335    data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2;                  /* WRAP 12 */
1336    data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3 | D3DWRAPCOORD_2;                  /* WRAP 13 */
1337    data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_1 | D3DWRAPCOORD_0;                  /* WRAP 14 */
1338    data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_0 | D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 15 */
1339    data->states[idx++] = TRUE;                  /* SEPARATEALPHABLENDENABLE */
1340    data->states[idx++] = D3DBLEND_ZERO;         /* SRCBLENDALPHA */
1341    data->states[idx++] = D3DBLEND_ONE;          /* DESTBLENDALPHA */
1342    data->states[idx++] = FALSE;                 /* BLENDOPALPHA */
1343 }
1344
1345 static HRESULT render_state_setup_handler(
1346     state_test* test) {
1347
1348     const render_state_arg* rsarg = test->test_arg;
1349
1350     render_state_context *ctx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(render_state_context));
1351     if (ctx == NULL) return E_FAIL;
1352     test->test_context = ctx;
1353
1354     test->return_data = &ctx->return_data_buffer;
1355     test->default_data = &ctx->default_data_buffer;
1356     test->initial_data = &ctx->default_data_buffer;
1357     test->test_data_in = &ctx->test_data_buffer;
1358     test->test_data_out = &ctx->test_data_buffer;
1359     test->poison_data = &ctx->poison_data_buffer;
1360
1361     render_state_default_data_init(rsarg->device_pparams, &ctx->default_data_buffer);
1362     render_state_test_data_init(&ctx->test_data_buffer);
1363     render_state_poison_data_init(&ctx->poison_data_buffer);
1364
1365     test->data_size = sizeof(render_state_data);
1366
1367     return D3D_OK;
1368 }
1369
1370 static void render_state_teardown_handler(
1371     state_test* test) {
1372
1373     HeapFree(GetProcessHeap(), 0, test->test_context);
1374 }
1375
1376 static void render_states_queue_test(
1377     state_test* test,
1378     const render_state_arg* test_arg) {
1379
1380     test->setup_handler = render_state_setup_handler;
1381     test->teardown_handler = render_state_teardown_handler;
1382     test->set_handler = render_state_set_handler;
1383     test->get_handler = render_state_get_handler;
1384     test->print_handler = render_state_print_handler;
1385     test->test_name = "set_get_render_states";
1386     test->test_arg = test_arg;
1387 }
1388
1389 /* =================== Main state tests function =============================== */
1390
1391 static void test_state_management(
1392     IDirect3DDevice9 *device,
1393     D3DPRESENT_PARAMETERS *device_pparams) {
1394
1395     HRESULT hret;
1396     D3DCAPS9 caps;
1397
1398     /* Test count: 2 for shader constants 
1399                    1 for lights
1400                    1 for transforms
1401                    1 for render states
1402      */
1403     const int max_tests = 5;
1404     state_test tests[5];
1405     unsigned int tcount = 0;
1406
1407     shader_constant_arg pshader_constant_arg;
1408     shader_constant_arg vshader_constant_arg;
1409     render_state_arg render_state_arg;
1410     light_arg light_arg;
1411
1412     hret = IDirect3DDevice9_GetDeviceCaps(device, &caps);
1413     ok(hret == D3D_OK, "GetDeviceCaps returned %#x.\n", hret);
1414     if (hret != D3D_OK) return;
1415
1416     texture_stages = caps.MaxTextureBlendStages;
1417
1418     /* Zero test memory */
1419     memset(tests, 0, sizeof(state_test) * max_tests);
1420
1421     if (caps.VertexShaderVersion & 0xffff) {
1422         vshader_constant_arg.idx = 0;
1423         vshader_constant_arg.pshader = FALSE;
1424         shader_constants_queue_test(&tests[tcount], &vshader_constant_arg);
1425         tcount++;
1426     }
1427
1428     if (caps.PixelShaderVersion & 0xffff) {
1429         pshader_constant_arg.idx = 0;
1430         pshader_constant_arg.pshader = TRUE;
1431         shader_constants_queue_test(&tests[tcount], &pshader_constant_arg);
1432         tcount++;
1433     }
1434
1435     light_arg.idx = 0;
1436     lights_queue_test(&tests[tcount], &light_arg);
1437     tcount++;
1438
1439     transform_queue_test(&tests[tcount]);
1440     tcount++;
1441
1442     render_state_arg.device_pparams = device_pparams;
1443     render_states_queue_test(&tests[tcount], &render_state_arg);
1444     tcount++;
1445
1446     execute_test_chain_all(device, tests, tcount);
1447 }
1448
1449 START_TEST(stateblock)
1450 {
1451     IDirect3DDevice9 *device_ptr = NULL;
1452     D3DPRESENT_PARAMETERS device_pparams;
1453     HRESULT hret;
1454
1455     d3d9_handle = LoadLibraryA("d3d9.dll");
1456     if (!d3d9_handle)
1457     {
1458         trace("Could not load d3d9.dll, skipping tests\n");
1459         return;
1460     }
1461
1462     hret = init_d3d9(&device_ptr, &device_pparams);
1463     if (hret != D3D_OK) return;
1464
1465     test_begin_end_state_block(device_ptr);
1466     test_state_management(device_ptr, &device_pparams);
1467
1468     if (device_ptr) IUnknown_Release(device_ptr);
1469 }