git.oblomov.eu Git - wine/blob - dlls/d3d9/tests/device.c

   1 /*
   2  * Copyright (C) 2006 Vitaliy Margolen
   3  * Copyright (C) 2006 Chris Robinson
   4  * Copyright (C) 2006-2007 Stefan Dösinger(For CodeWeavers)
   5  * Copyright 2007 Henri Verbeet
   6  * Copyright (C) 2008 Rico Schüller
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COBJMACROS
  24 #include <windowsx.h>
  25 #include <d3d9.h>
  26 #include "wine/test.h"
  27
  28 static INT screen_width;
  29 static INT screen_height;
  30
  31 static IDirect3D9 *(WINAPI *pDirect3DCreate9)(UINT);
  32
  33 static int get_refcount(IUnknown *object)
  34 {
  35     IUnknown_AddRef( object );
  36     return IUnknown_Release( object );
  37 }
  38
  39 /* try to make sure pending X events have been processed before continuing */
  40 static void flush_events(void)
  41 {
  42     MSG msg;
  43     int diff = 200;
  44     int min_timeout = 100;
  45     DWORD time = GetTickCount() + diff;
  46
  47     while (diff > 0)
  48     {
  49         if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
  50         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
  51         diff = time - GetTickCount();
  52     }
  53 }
  54
  55 static IDirect3DDevice9 *create_device(IDirect3D9 *d3d9, HWND device_window, HWND focus_window, BOOL windowed)
  56 {
  57     D3DPRESENT_PARAMETERS present_parameters = {0};
  58     IDirect3DDevice9 *device;
  59
  60     present_parameters.Windowed = windowed;
  61     present_parameters.hDeviceWindow = device_window;
  62     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
  63     present_parameters.BackBufferWidth = screen_width;
  64     present_parameters.BackBufferHeight = screen_height;
  65     present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
  66     present_parameters.EnableAutoDepthStencil = TRUE;
  67     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
  68
  69     if (SUCCEEDED(IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, focus_window,
  70             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device))) return device;
  71
  72     present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
  73     if (SUCCEEDED(IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, focus_window,
  74             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device))) return device;
  75
  76     if (SUCCEEDED(IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, focus_window,
  77             D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device))) return device;
  78
  79     return NULL;
  80 }
  81
  82 static HRESULT reset_device(IDirect3DDevice9 *device, HWND device_window, BOOL windowed)
  83 {
  84     D3DPRESENT_PARAMETERS present_parameters = {0};
  85
  86     present_parameters.Windowed = windowed;
  87     present_parameters.hDeviceWindow = device_window;
  88     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
  89     present_parameters.BackBufferWidth = screen_width;
  90     present_parameters.BackBufferHeight = screen_height;
  91     present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
  92     present_parameters.EnableAutoDepthStencil = TRUE;
  93     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
  94
  95     return IDirect3DDevice9_Reset(device, &present_parameters);
  96 }
  97
  98 #define CHECK_CALL(r,c,d,rc) \
  99     if (SUCCEEDED(r)) {\
 100         int tmp1 = get_refcount( (IUnknown *)d ); \
 101         int rc_new = rc; \
 102         ok(tmp1 == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, tmp1); \
 103     } else {\
 104         trace("%s failed: %08x\n", c, r); \
 105     }
 106
 107 #define CHECK_RELEASE(obj,d,rc) \
 108     if (obj) { \
 109         int tmp1, rc_new = rc; \
 110         IUnknown_Release( (IUnknown*)obj ); \
 111         tmp1 = get_refcount( (IUnknown *)d ); \
 112         ok(tmp1 == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, tmp1); \
 113     }
 114
 115 #define CHECK_REFCOUNT(obj,rc) \
 116     { \
 117         int rc_new = rc; \
 118         int count = get_refcount( (IUnknown *)obj ); \
 119         ok(count == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, count); \
 120     }
 121
 122 #define CHECK_RELEASE_REFCOUNT(obj,rc) \
 123     { \
 124         int rc_new = rc; \
 125         int count = IUnknown_Release( (IUnknown *)obj ); \
 126         ok(count == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, count); \
 127     }
 128
 129 #define CHECK_ADDREF_REFCOUNT(obj,rc) \
 130     { \
 131         int rc_new = rc; \
 132         int count = IUnknown_AddRef( (IUnknown *)obj ); \
 133         ok(count == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, count); \
 134     }
 135
 136 #define CHECK_SURFACE_CONTAINER(obj,iid,expected) \
 137     { \
 138         void *container_ptr = (void *)0x1337c0d3; \
 139         hr = IDirect3DSurface9_GetContainer(obj, &iid, &container_ptr); \
 140         ok(SUCCEEDED(hr) && container_ptr == expected, "GetContainer returned: hr %#x, container_ptr %p. " \
 141             "Expected hr %#x, container_ptr %p\n", hr, container_ptr, S_OK, expected); \
 142         if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr); \
 143     }
 144
 145 static void check_mipmap_levels(IDirect3DDevice9 *device, UINT width, UINT height, UINT count)
 146 {
 147     IDirect3DBaseTexture9* texture = NULL;
 148     HRESULT hr = IDirect3DDevice9_CreateTexture( device, width, height, 0, 0,
 149             D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, (IDirect3DTexture9**) &texture, NULL );
 150
 151     if (SUCCEEDED(hr)) {
 152         DWORD levels = IDirect3DBaseTexture9_GetLevelCount(texture);
 153         ok(levels == count, "Invalid level count. Expected %d got %u\n", count, levels);
 154     } else
 155         trace("CreateTexture failed: %08x\n", hr);
 156
 157     if (texture) IDirect3DBaseTexture9_Release( texture );
 158 }
 159
 160 static void test_mipmap_levels(void)
 161 {
 162
 163     HRESULT               hr;
 164     HWND                  hwnd = NULL;
 165
 166     IDirect3D9            *pD3d = NULL;
 167     IDirect3DDevice9      *pDevice = NULL;
 168     D3DPRESENT_PARAMETERS d3dpp;
 169     D3DDISPLAYMODE        d3ddm;
 170
 171     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
 172     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
 173     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 174     ok(hwnd != NULL, "Failed to create window\n");
 175     if (!pD3d || !hwnd) goto cleanup;
 176
 177     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 178     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 179     d3dpp.Windowed         = TRUE;
 180     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 181     d3dpp.BackBufferFormat = d3ddm.Format;
 182
 183     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_NULLREF, hwnd,
 184                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 185     ok(SUCCEEDED(hr) || hr == D3DERR_NOTAVAILABLE, "Failed to create IDirect3D9Device (%08x)\n", hr);
 186     if (FAILED(hr)) {
 187         skip("failed to create a d3d device\n");
 188         goto cleanup;
 189     }
 190
 191     check_mipmap_levels(pDevice, 32, 32, 6);
 192     check_mipmap_levels(pDevice, 256, 1, 9);
 193     check_mipmap_levels(pDevice, 1, 256, 9);
 194     check_mipmap_levels(pDevice, 1, 1, 1);
 195
 196 cleanup:
 197     if (pDevice)
 198     {
 199         UINT refcount = IDirect3DDevice9_Release( pDevice );
 200         ok(!refcount, "Device has %u references left.\n", refcount);
 201     }
 202     if (pD3d) IDirect3D9_Release( pD3d );
 203     DestroyWindow( hwnd );
 204 }
 205
 206 static void test_checkdevicemultisampletype(void)
 207 {
 208
 209     HRESULT               hr;
 210     HWND                  hwnd = NULL;
 211
 212     IDirect3D9            *pD3d = NULL;
 213     IDirect3DDevice9      *pDevice = NULL;
 214     D3DPRESENT_PARAMETERS d3dpp;
 215     D3DDISPLAYMODE        d3ddm;
 216     DWORD                 qualityLevels;
 217
 218     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
 219     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
 220     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 221     ok(hwnd != NULL, "Failed to create window\n");
 222     if (!pD3d || !hwnd) goto cleanup;
 223
 224     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 225     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 226     d3dpp.Windowed         = TRUE;
 227     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 228     d3dpp.BackBufferFormat = d3ddm.Format;
 229
 230     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_NULLREF, hwnd,
 231                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 232     ok(SUCCEEDED(hr) || hr == D3DERR_NOTAVAILABLE, "Failed to create IDirect3D9Device (%08x)\n", hr);
 233     if (FAILED(hr)) {
 234         skip("failed to create a d3d device\n");
 235         goto cleanup;
 236     }
 237
 238     qualityLevels = 0;
 239
 240     hr = IDirect3D9_CheckDeviceMultiSampleType(pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE,
 241     D3DMULTISAMPLE_NONE, &qualityLevels);
 242     ok(SUCCEEDED(hr) || hr == D3DERR_NOTAVAILABLE, "CheckDeviceMultiSampleType failed with (%08x)\n", hr);
 243     if(hr == D3DERR_NOTAVAILABLE)
 244     {
 245         skip("IDirect3D9_CheckDeviceMultiSampleType not available\n");
 246         goto cleanup;
 247     }
 248     ok(qualityLevels == 1,"qualitylevel is not 1 but %d\n",qualityLevels);
 249
 250     hr = IDirect3D9_CheckDeviceMultiSampleType(pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, FALSE,
 251     D3DMULTISAMPLE_NONE, &qualityLevels);
 252     ok(SUCCEEDED(hr), "CheckDeviceMultiSampleType failed with (%08x)\n", hr);
 253     ok(qualityLevels == 1,"qualitylevel is not 1 but %d\n",qualityLevels);
 254
 255 cleanup:
 256     if (pDevice)
 257     {
 258         UINT refcount = IDirect3DDevice9_Release( pDevice );
 259         ok(!refcount, "Device has %u references left.\n", refcount);
 260     }
 261     if (pD3d) IDirect3D9_Release( pD3d );
 262     DestroyWindow( hwnd );
 263 }
 264
 265 static void test_swapchain(void)
 266 {
 267     HRESULT                      hr;
 268     HWND                         hwnd               = NULL;
 269     IDirect3D9                  *pD3d               = NULL;
 270     IDirect3DDevice9            *pDevice            = NULL;
 271     IDirect3DSwapChain9         *swapchain0         = NULL;
 272     IDirect3DSwapChain9         *swapchain1         = NULL;
 273     IDirect3DSwapChain9         *swapchain2         = NULL;
 274     IDirect3DSwapChain9         *swapchain3         = NULL;
 275     IDirect3DSwapChain9         *swapchainX         = NULL;
 276     IDirect3DSurface9           *backbuffer         = NULL;
 277     D3DPRESENT_PARAMETERS        d3dpp;
 278     D3DDISPLAYMODE               d3ddm;
 279
 280     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
 281     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
 282     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 283     ok(hwnd != NULL, "Failed to create window\n");
 284     if (!pD3d || !hwnd) goto cleanup;
 285
 286     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 287     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 288     d3dpp.Windowed         = TRUE;
 289     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 290     d3dpp.BackBufferFormat = d3ddm.Format;
 291     d3dpp.BackBufferCount  = 0;
 292
 293     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 294                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 295     ok(hr == S_OK || hr == D3DERR_NOTAVAILABLE,
 296        "Failed to create IDirect3D9Device (%08x)\n", hr);
 297     if (FAILED(hr)) goto cleanup;
 298
 299     /* Check if the back buffer count was modified */
 300     ok(d3dpp.BackBufferCount == 1, "The back buffer count in the presentparams struct is %d\n", d3dpp.BackBufferCount);
 301
 302     /* Get the implicit swapchain */
 303     hr = IDirect3DDevice9_GetSwapChain(pDevice, 0, &swapchain0);
 304     ok(SUCCEEDED(hr), "Failed to get the implicit swapchain (%08x)\n", hr);
 305     if(swapchain0) IDirect3DSwapChain9_Release(swapchain0);
 306
 307     /* Check if there is a back buffer */
 308     hr = IDirect3DSwapChain9_GetBackBuffer(swapchain0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
 309     ok(SUCCEEDED(hr), "Failed to get the back buffer (%08x)\n", hr);
 310     ok(backbuffer != NULL, "The back buffer is NULL\n");
 311     if(backbuffer) IDirect3DSurface9_Release(backbuffer);
 312
 313     /* Try to get a nonexistent swapchain */
 314     hr = IDirect3DDevice9_GetSwapChain(pDevice, 1, &swapchainX);
 315     ok(hr == D3DERR_INVALIDCALL, "GetSwapChain on an nonexistent swapchain returned (%08x)\n", hr);
 316     ok(swapchainX == NULL, "Swapchain 1 is %p\n", swapchainX);
 317     if(swapchainX) IDirect3DSwapChain9_Release(swapchainX);
 318
 319     /* Create a bunch of swapchains */
 320     d3dpp.BackBufferCount = 0;
 321     hr = IDirect3DDevice9_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain1);
 322     ok(SUCCEEDED(hr), "Failed to create a swapchain (%08x)\n", hr);
 323     ok(d3dpp.BackBufferCount == 1, "The back buffer count in the presentparams struct is %d\n", d3dpp.BackBufferCount);
 324
 325     d3dpp.BackBufferCount  = 1;
 326     hr = IDirect3DDevice9_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain2);
 327     ok(SUCCEEDED(hr), "Failed to create a swapchain (%08x)\n", hr);
 328
 329     d3dpp.BackBufferCount  = 2;
 330     hr = IDirect3DDevice9_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain3);
 331     ok(SUCCEEDED(hr), "Failed to create a swapchain (%08x)\n", hr);
 332     if(SUCCEEDED(hr)) {
 333         /* Swapchain 3, created with backbuffercount 2 */
 334         backbuffer = (void *) 0xdeadbeef;
 335         hr = IDirect3DSwapChain9_GetBackBuffer(swapchain3, 0, 0, &backbuffer);
 336         ok(SUCCEEDED(hr), "Failed to get the 1st back buffer (%08x)\n", hr);
 337         ok(backbuffer != NULL && backbuffer != (void *) 0xdeadbeef, "The back buffer is %p\n", backbuffer);
 338         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 339
 340         backbuffer = (void *) 0xdeadbeef;
 341         hr = IDirect3DSwapChain9_GetBackBuffer(swapchain3, 1, 0, &backbuffer);
 342         ok(SUCCEEDED(hr), "Failed to get the 2nd back buffer (%08x)\n", hr);
 343         ok(backbuffer != NULL && backbuffer != (void *) 0xdeadbeef, "The back buffer is %p\n", backbuffer);
 344         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 345
 346         backbuffer = (void *) 0xdeadbeef;
 347         hr = IDirect3DSwapChain9_GetBackBuffer(swapchain3, 2, 0, &backbuffer);
 348         ok(hr == D3DERR_INVALIDCALL, "GetBackBuffer returned %08x\n", hr);
 349         ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 350         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 351
 352         backbuffer = (void *) 0xdeadbeef;
 353         hr = IDirect3DSwapChain9_GetBackBuffer(swapchain3, 3, 0, &backbuffer);
 354         ok(FAILED(hr), "Failed to get the back buffer (%08x)\n", hr);
 355         ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 356         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 357     }
 358
 359     /* Check the back buffers of the swapchains */
 360     /* Swapchain 1, created with backbuffercount 0 */
 361     hr = IDirect3DSwapChain9_GetBackBuffer(swapchain1, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
 362     ok(SUCCEEDED(hr), "Failed to get the back buffer (%08x)\n", hr);
 363     ok(backbuffer != NULL, "The back buffer is NULL (%08x)\n", hr);
 364     if(backbuffer) IDirect3DSurface9_Release(backbuffer);
 365
 366     backbuffer = (void *) 0xdeadbeef;
 367     hr = IDirect3DSwapChain9_GetBackBuffer(swapchain1, 1, 0, &backbuffer);
 368     ok(FAILED(hr), "Failed to get the back buffer (%08x)\n", hr);
 369     ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 370     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 371
 372     /* Swapchain 2 - created with backbuffercount 1 */
 373     backbuffer = (void *) 0xdeadbeef;
 374     hr = IDirect3DSwapChain9_GetBackBuffer(swapchain2, 0, 0, &backbuffer);
 375     ok(SUCCEEDED(hr), "Failed to get the back buffer (%08x)\n", hr);
 376     ok(backbuffer != NULL && backbuffer != (void *) 0xdeadbeef, "The back buffer is %p\n", backbuffer);
 377     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 378
 379     backbuffer = (void *) 0xdeadbeef;
 380     hr = IDirect3DSwapChain9_GetBackBuffer(swapchain2, 1, 0, &backbuffer);
 381     ok(hr == D3DERR_INVALIDCALL, "GetBackBuffer returned %08x\n", hr);
 382     ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 383     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 384
 385     backbuffer = (void *) 0xdeadbeef;
 386     hr = IDirect3DSwapChain9_GetBackBuffer(swapchain2, 2, 0, &backbuffer);
 387     ok(FAILED(hr), "Failed to get the back buffer (%08x)\n", hr);
 388     ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 389     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface9_Release(backbuffer);
 390
 391     /* Try getSwapChain on a manually created swapchain
 392      * it should fail, apparently GetSwapChain only returns implicit swapchains
 393      */
 394     swapchainX = (void *) 0xdeadbeef;
 395     hr = IDirect3DDevice9_GetSwapChain(pDevice, 1, &swapchainX);
 396     ok(hr == D3DERR_INVALIDCALL, "Failed to get the second swapchain (%08x)\n", hr);
 397     ok(swapchainX == NULL, "The swapchain pointer is %p\n", swapchainX);
 398     if(swapchainX && swapchainX != (void *) 0xdeadbeef ) IDirect3DSwapChain9_Release(swapchainX);
 399
 400 cleanup:
 401     if(swapchain1) IDirect3DSwapChain9_Release(swapchain1);
 402     if(swapchain2) IDirect3DSwapChain9_Release(swapchain2);
 403     if(swapchain3) IDirect3DSwapChain9_Release(swapchain3);
 404     if (pDevice)
 405     {
 406         UINT refcount = IDirect3DDevice9_Release(pDevice);
 407         ok(!refcount, "Device has %u references left.\n", refcount);
 408     }
 409     if (pD3d) IDirect3D9_Release(pD3d);
 410     DestroyWindow( hwnd );
 411 }
 412
 413 /* Shared between two functions */
 414 static const DWORD simple_vs[] = {0xFFFE0101,       /* vs_1_1               */
 415     0x0000001F, 0x80000000, 0x900F0000,             /* dcl_position0 v0     */
 416     0x00000009, 0xC0010000, 0x90E40000, 0xA0E40000, /* dp4 oPos.x, v0, c0   */
 417     0x00000009, 0xC0020000, 0x90E40000, 0xA0E40001, /* dp4 oPos.y, v0, c1   */
 418     0x00000009, 0xC0040000, 0x90E40000, 0xA0E40002, /* dp4 oPos.z, v0, c2   */
 419     0x00000009, 0xC0080000, 0x90E40000, 0xA0E40003, /* dp4 oPos.w, v0, c3   */
 420     0x0000FFFF};                                    /* END                  */
 421
 422 static void test_refcount(void)
 423 {
 424     HRESULT                      hr;
 425     HWND                         hwnd               = NULL;
 426     IDirect3D9                  *pD3d               = NULL;
 427     IDirect3D9                  *pD3d2              = NULL;
 428     IDirect3DDevice9            *pDevice            = NULL;
 429     IDirect3DVertexBuffer9      *pVertexBuffer      = NULL;
 430     IDirect3DIndexBuffer9       *pIndexBuffer       = NULL;
 431     IDirect3DVertexDeclaration9 *pVertexDeclaration = NULL;
 432     IDirect3DVertexShader9      *pVertexShader      = NULL;
 433     IDirect3DPixelShader9       *pPixelShader       = NULL;
 434     IDirect3DCubeTexture9       *pCubeTexture       = NULL;
 435     IDirect3DTexture9           *pTexture           = NULL;
 436     IDirect3DVolumeTexture9     *pVolumeTexture     = NULL;
 437     IDirect3DVolume9            *pVolumeLevel       = NULL;
 438     IDirect3DSurface9           *pStencilSurface    = NULL;
 439     IDirect3DSurface9           *pOffscreenSurface  = NULL;
 440     IDirect3DSurface9           *pRenderTarget      = NULL;
 441     IDirect3DSurface9           *pRenderTarget2     = NULL;
 442     IDirect3DSurface9           *pRenderTarget3     = NULL;
 443     IDirect3DSurface9           *pTextureLevel      = NULL;
 444     IDirect3DSurface9           *pBackBuffer        = NULL;
 445     IDirect3DStateBlock9        *pStateBlock        = NULL;
 446     IDirect3DStateBlock9        *pStateBlock1       = NULL;
 447     IDirect3DSwapChain9         *pSwapChain         = NULL;
 448     IDirect3DQuery9             *pQuery             = NULL;
 449     D3DPRESENT_PARAMETERS        d3dpp;
 450     D3DDISPLAYMODE               d3ddm;
 451     int                          refcount = 0, tmp;
 452
 453     D3DVERTEXELEMENT9 decl[] =
 454     {
 455         D3DDECL_END()
 456     };
 457     static DWORD simple_ps[] = {0xFFFF0101,                                     /* ps_1_1                       */
 458         0x00000051, 0xA00F0001, 0x3F800000, 0x00000000, 0x00000000, 0x00000000, /* def c1 = 1.0, 0.0, 0.0, 0.0  */
 459         0x00000042, 0xB00F0000,                                                 /* tex t0                       */
 460         0x00000008, 0x800F0000, 0xA0E40001, 0xA0E40000,                         /* dp3 r0, c1, c0               */
 461         0x00000005, 0x800F0000, 0x90E40000, 0x80E40000,                         /* mul r0, v0, r0               */
 462         0x00000005, 0x800F0000, 0xB0E40000, 0x80E40000,                         /* mul r0, t0, r0               */
 463         0x0000FFFF};                                                            /* END                          */
 464
 465
 466     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
 467     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
 468     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 469     ok(hwnd != NULL, "Failed to create window\n");
 470     if (!pD3d || !hwnd) goto cleanup;
 471
 472     CHECK_REFCOUNT( pD3d, 1 );
 473
 474     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 475     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 476     d3dpp.Windowed         = TRUE;
 477     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 478     d3dpp.BackBufferFormat = d3ddm.Format;
 479     d3dpp.EnableAutoDepthStencil = TRUE;
 480     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
 481
 482     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 483                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 484     ok(hr == S_OK || hr == D3DERR_NOTAVAILABLE,
 485        "Failed to create IDirect3D9Device (%08x)\n", hr);
 486     if (FAILED(hr)) goto cleanup;
 487
 488     refcount = get_refcount( (IUnknown *)pDevice );
 489     ok(refcount == 1, "Invalid device RefCount %d\n", refcount);
 490
 491     CHECK_REFCOUNT( pD3d, 2 );
 492
 493     hr = IDirect3DDevice9_GetDirect3D(pDevice, &pD3d2);
 494     CHECK_CALL( hr, "GetDirect3D", pDevice, refcount );
 495
 496     ok(pD3d2 == pD3d, "Expected IDirect3D9 pointers to be equal\n");
 497     CHECK_REFCOUNT( pD3d, 3 );
 498     CHECK_RELEASE_REFCOUNT( pD3d, 2 );
 499
 500     /**
 501      * Check refcount of implicit surfaces and implicit swapchain. Findings:
 502      *   - the container is the device OR swapchain
 503      *   - they hold a reference to the device
 504      *   - they are created with a refcount of 0 (Get/Release returns original refcount)
 505      *   - they are not freed if refcount reaches 0.
 506      *   - the refcount is not forwarded to the container.
 507      */
 508     hr = IDirect3DDevice9_GetSwapChain(pDevice, 0, &pSwapChain);
 509     CHECK_CALL( hr, "GetSwapChain", pDevice, ++refcount);
 510     if (pSwapChain)
 511     {
 512         CHECK_REFCOUNT( pSwapChain, 1);
 513
 514         hr = IDirect3DDevice9_GetRenderTarget(pDevice, 0, &pRenderTarget);
 515         CHECK_CALL( hr, "GetRenderTarget", pDevice, ++refcount);
 516         CHECK_REFCOUNT( pSwapChain, 1);
 517         if(pRenderTarget)
 518         {
 519             CHECK_SURFACE_CONTAINER( pRenderTarget, IID_IDirect3DSwapChain9, pSwapChain);
 520             CHECK_REFCOUNT( pRenderTarget, 1);
 521
 522             CHECK_ADDREF_REFCOUNT(pRenderTarget, 2);
 523             CHECK_REFCOUNT(pDevice, refcount);
 524             CHECK_RELEASE_REFCOUNT(pRenderTarget, 1);
 525             CHECK_REFCOUNT(pDevice, refcount);
 526
 527             hr = IDirect3DDevice9_GetRenderTarget(pDevice, 0, &pRenderTarget);
 528             CHECK_CALL( hr, "GetRenderTarget", pDevice, refcount);
 529             CHECK_REFCOUNT( pRenderTarget, 2);
 530             CHECK_RELEASE_REFCOUNT( pRenderTarget, 1);
 531             CHECK_RELEASE_REFCOUNT( pRenderTarget, 0);
 532             CHECK_REFCOUNT( pDevice, --refcount);
 533
 534             /* The render target is released with the device, so AddRef with refcount=0 is fine here. */
 535             CHECK_ADDREF_REFCOUNT(pRenderTarget, 1);
 536             CHECK_REFCOUNT(pDevice, ++refcount);
 537             CHECK_RELEASE_REFCOUNT(pRenderTarget, 0);
 538             CHECK_REFCOUNT(pDevice, --refcount);
 539         }
 540
 541         /* Render target and back buffer are identical. */
 542         hr = IDirect3DDevice9_GetBackBuffer(pDevice, 0, 0, 0, &pBackBuffer);
 543         CHECK_CALL( hr, "GetBackBuffer", pDevice, ++refcount);
 544         if(pBackBuffer)
 545         {
 546             CHECK_RELEASE_REFCOUNT(pBackBuffer, 0);
 547             ok(pRenderTarget == pBackBuffer, "RenderTarget=%p and BackBuffer=%p should be the same.\n",
 548             pRenderTarget, pBackBuffer);
 549             pBackBuffer = NULL;
 550         }
 551         CHECK_REFCOUNT( pDevice, --refcount);
 552
 553         hr = IDirect3DDevice9_GetDepthStencilSurface(pDevice, &pStencilSurface);
 554         CHECK_CALL( hr, "GetDepthStencilSurface", pDevice, ++refcount);
 555         CHECK_REFCOUNT( pSwapChain, 1);
 556         if(pStencilSurface)
 557         {
 558             CHECK_SURFACE_CONTAINER( pStencilSurface, IID_IDirect3DDevice9, pDevice);
 559             CHECK_REFCOUNT( pStencilSurface, 1);
 560
 561             CHECK_ADDREF_REFCOUNT(pStencilSurface, 2);
 562             CHECK_REFCOUNT(pDevice, refcount);
 563             CHECK_RELEASE_REFCOUNT(pStencilSurface, 1);
 564             CHECK_REFCOUNT(pDevice, refcount);
 565
 566             CHECK_RELEASE_REFCOUNT( pStencilSurface, 0);
 567             CHECK_REFCOUNT( pDevice, --refcount);
 568
 569             /* The stencil surface is released with the device, so AddRef with refcount=0 is fine here. */
 570             CHECK_ADDREF_REFCOUNT(pStencilSurface, 1);
 571             CHECK_REFCOUNT(pDevice, ++refcount);
 572             CHECK_RELEASE_REFCOUNT(pStencilSurface, 0);
 573             CHECK_REFCOUNT(pDevice, --refcount);
 574             pStencilSurface = NULL;
 575         }
 576
 577         CHECK_RELEASE_REFCOUNT( pSwapChain, 0);
 578         CHECK_REFCOUNT( pDevice, --refcount);
 579
 580         /* The implicit swapchwin is released with the device, so AddRef with refcount=0 is fine here. */
 581         CHECK_ADDREF_REFCOUNT(pSwapChain, 1);
 582         CHECK_REFCOUNT(pDevice, ++refcount);
 583         CHECK_RELEASE_REFCOUNT(pSwapChain, 0);
 584         CHECK_REFCOUNT(pDevice, --refcount);
 585         pSwapChain = NULL;
 586     }
 587
 588     /* Buffers */
 589     hr = IDirect3DDevice9_CreateIndexBuffer( pDevice, 16, 0, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &pIndexBuffer, NULL );
 590     CHECK_CALL( hr, "CreateIndexBuffer", pDevice, ++refcount );
 591     if(pIndexBuffer)
 592     {
 593         tmp = get_refcount( (IUnknown *)pIndexBuffer );
 594
 595         hr = IDirect3DDevice9_SetIndices(pDevice, pIndexBuffer);
 596         CHECK_CALL( hr, "SetIndices", pIndexBuffer, tmp);
 597         hr = IDirect3DDevice9_SetIndices(pDevice, NULL);
 598         CHECK_CALL( hr, "SetIndices", pIndexBuffer, tmp);
 599     }
 600
 601     hr = IDirect3DDevice9_CreateVertexBuffer( pDevice, 16, 0, D3DFVF_XYZ, D3DPOOL_DEFAULT, &pVertexBuffer, NULL );
 602     CHECK_CALL( hr, "CreateVertexBuffer", pDevice, ++refcount );
 603     if(pVertexBuffer)
 604     {
 605         IDirect3DVertexBuffer9 *pVBuf = (void*)~0;
 606         UINT offset = ~0;
 607         UINT stride = ~0;
 608
 609         tmp = get_refcount( (IUnknown *)pVertexBuffer );
 610
 611         hr = IDirect3DDevice9_SetStreamSource(pDevice, 0, pVertexBuffer, 0, 3 * sizeof(float));
 612         CHECK_CALL( hr, "SetStreamSource", pVertexBuffer, tmp);
 613         hr = IDirect3DDevice9_SetStreamSource(pDevice, 0, NULL, 0, 0);
 614         CHECK_CALL( hr, "SetStreamSource", pVertexBuffer, tmp);
 615
 616         hr = IDirect3DDevice9_GetStreamSource(pDevice, 0, &pVBuf, &offset, &stride);
 617         ok(SUCCEEDED(hr), "GetStreamSource did not succeed with NULL stream!\n");
 618         ok(pVBuf==NULL, "pVBuf not NULL (%p)!\n", pVBuf);
 619         ok(stride==3*sizeof(float), "stride not 3 floats (got %u)!\n", stride);
 620         ok(offset==0, "offset not 0 (got %u)!\n", offset);
 621     }
 622     /* Shaders */
 623     hr = IDirect3DDevice9_CreateVertexDeclaration( pDevice, decl, &pVertexDeclaration );
 624     CHECK_CALL( hr, "CreateVertexDeclaration", pDevice, ++refcount );
 625     hr = IDirect3DDevice9_CreateVertexShader( pDevice, simple_vs, &pVertexShader );
 626     CHECK_CALL( hr, "CreateVertexShader", pDevice, ++refcount );
 627     hr = IDirect3DDevice9_CreatePixelShader( pDevice, simple_ps, &pPixelShader );
 628     CHECK_CALL( hr, "CreatePixelShader", pDevice, ++refcount );
 629     /* Textures */
 630     hr = IDirect3DDevice9_CreateTexture( pDevice, 32, 32, 3, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pTexture, NULL );
 631     CHECK_CALL( hr, "CreateTexture", pDevice, ++refcount );
 632     if (pTexture)
 633     {
 634         tmp = get_refcount( (IUnknown *)pTexture );
 635
 636         /* SetTexture should not increase refcounts */
 637         hr = IDirect3DDevice9_SetTexture(pDevice, 0, (IDirect3DBaseTexture9 *) pTexture);
 638         CHECK_CALL( hr, "SetTexture", pTexture, tmp);
 639         hr = IDirect3DDevice9_SetTexture(pDevice, 0, NULL);
 640         CHECK_CALL( hr, "SetTexture", pTexture, tmp);
 641
 642         /* This should not increment device refcount */
 643         hr = IDirect3DTexture9_GetSurfaceLevel( pTexture, 1, &pTextureLevel );
 644         CHECK_CALL( hr, "GetSurfaceLevel", pDevice, refcount );
 645         /* But should increment texture's refcount */
 646         CHECK_REFCOUNT( pTexture, tmp+1 );
 647         /* Because the texture and surface refcount are identical */
 648         if (pTextureLevel)
 649         {
 650             CHECK_REFCOUNT        ( pTextureLevel, tmp+1 );
 651             CHECK_ADDREF_REFCOUNT ( pTextureLevel, tmp+2 );
 652             CHECK_REFCOUNT        ( pTexture     , tmp+2 );
 653             CHECK_RELEASE_REFCOUNT( pTextureLevel, tmp+1 );
 654             CHECK_REFCOUNT        ( pTexture     , tmp+1 );
 655             CHECK_RELEASE_REFCOUNT( pTexture     , tmp   );
 656             CHECK_REFCOUNT        ( pTextureLevel, tmp   );
 657         }
 658     }
 659     hr = IDirect3DDevice9_CreateCubeTexture( pDevice, 32, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pCubeTexture, NULL );
 660     CHECK_CALL( hr, "CreateCubeTexture", pDevice, ++refcount );
 661     hr = IDirect3DDevice9_CreateVolumeTexture( pDevice, 32, 32, 2, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pVolumeTexture, NULL );
 662     CHECK_CALL( hr, "CreateVolumeTexture", pDevice, ++refcount );
 663     if (pVolumeTexture)
 664     {
 665         tmp = get_refcount( (IUnknown *)pVolumeTexture );
 666
 667         /* This should not increment device refcount */
 668         hr = IDirect3DVolumeTexture9_GetVolumeLevel(pVolumeTexture, 0, &pVolumeLevel);
 669         CHECK_CALL( hr, "GetVolumeLevel", pDevice, refcount );
 670         /* But should increment volume texture's refcount */
 671         CHECK_REFCOUNT( pVolumeTexture, tmp+1 );
 672         /* Because the volume texture and volume refcount are identical */
 673         if (pVolumeLevel)
 674         {
 675             CHECK_REFCOUNT        ( pVolumeLevel  , tmp+1 );
 676             CHECK_ADDREF_REFCOUNT ( pVolumeLevel  , tmp+2 );
 677             CHECK_REFCOUNT        ( pVolumeTexture, tmp+2 );
 678             CHECK_RELEASE_REFCOUNT( pVolumeLevel  , tmp+1 );
 679             CHECK_REFCOUNT        ( pVolumeTexture, tmp+1 );
 680             CHECK_RELEASE_REFCOUNT( pVolumeTexture, tmp   );
 681             CHECK_REFCOUNT        ( pVolumeLevel  , tmp   );
 682         }
 683     }
 684     /* Surfaces */
 685     hr = IDirect3DDevice9_CreateDepthStencilSurface( pDevice, 32, 32, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &pStencilSurface, NULL );
 686     CHECK_CALL( hr, "CreateDepthStencilSurface", pDevice, ++refcount );
 687     CHECK_REFCOUNT( pStencilSurface, 1 );
 688     hr = IDirect3DDevice9_CreateOffscreenPlainSurface( pDevice, 32, 32, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pOffscreenSurface, NULL );
 689     CHECK_CALL( hr, "CreateOffscreenPlainSurface", pDevice, ++refcount );
 690     CHECK_REFCOUNT( pOffscreenSurface, 1 );
 691     hr = IDirect3DDevice9_CreateRenderTarget( pDevice, 32, 32, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &pRenderTarget3, NULL );
 692     CHECK_CALL( hr, "CreateRenderTarget", pDevice, ++refcount );
 693     CHECK_REFCOUNT( pRenderTarget3, 1 );
 694     /* Misc */
 695     hr = IDirect3DDevice9_CreateStateBlock( pDevice, D3DSBT_ALL, &pStateBlock );
 696     CHECK_CALL( hr, "CreateStateBlock", pDevice, ++refcount );
 697     hr = IDirect3DDevice9_CreateAdditionalSwapChain( pDevice, &d3dpp, &pSwapChain );
 698     CHECK_CALL( hr, "CreateAdditionalSwapChain", pDevice, ++refcount );
 699     if(pSwapChain)
 700     {
 701         /* check implicit back buffer */
 702         hr = IDirect3DSwapChain9_GetBackBuffer(pSwapChain, 0, 0, &pBackBuffer);
 703         CHECK_CALL( hr, "GetBackBuffer", pDevice, ++refcount);
 704         CHECK_REFCOUNT( pSwapChain, 1);
 705         if(pBackBuffer)
 706         {
 707             CHECK_SURFACE_CONTAINER( pBackBuffer, IID_IDirect3DSwapChain9, pSwapChain);
 708             CHECK_REFCOUNT( pBackBuffer, 1);
 709             CHECK_RELEASE_REFCOUNT( pBackBuffer, 0);
 710             CHECK_REFCOUNT( pDevice, --refcount);
 711
 712             /* The back buffer is released with the swapchain, so AddRef with refcount=0 is fine here. */
 713             CHECK_ADDREF_REFCOUNT(pBackBuffer, 1);
 714             CHECK_REFCOUNT(pDevice, ++refcount);
 715             CHECK_RELEASE_REFCOUNT(pBackBuffer, 0);
 716             CHECK_REFCOUNT(pDevice, --refcount);
 717             pBackBuffer = NULL;
 718         }
 719         CHECK_REFCOUNT( pSwapChain, 1);
 720     }
 721     hr = IDirect3DDevice9_CreateQuery( pDevice, D3DQUERYTYPE_EVENT, &pQuery );
 722     CHECK_CALL( hr, "CreateQuery", pDevice, ++refcount );
 723
 724     hr = IDirect3DDevice9_BeginStateBlock( pDevice );
 725     CHECK_CALL( hr, "BeginStateBlock", pDevice, refcount );
 726     hr = IDirect3DDevice9_EndStateBlock( pDevice, &pStateBlock1 );
 727     CHECK_CALL( hr, "EndStateBlock", pDevice, ++refcount );
 728
 729     /* The implicit render target is not freed if refcount reaches 0.
 730      * Otherwise GetRenderTarget would re-allocate it and the pointer would change.*/
 731     hr = IDirect3DDevice9_GetRenderTarget(pDevice, 0, &pRenderTarget2);
 732     CHECK_CALL( hr, "GetRenderTarget", pDevice, ++refcount);
 733     if(pRenderTarget2)
 734     {
 735         CHECK_RELEASE_REFCOUNT(pRenderTarget2, 0);
 736         ok(pRenderTarget == pRenderTarget2, "RenderTarget=%p and RenderTarget2=%p should be the same.\n",
 737            pRenderTarget, pRenderTarget2);
 738         CHECK_REFCOUNT( pDevice, --refcount);
 739         pRenderTarget2 = NULL;
 740     }
 741     pRenderTarget = NULL;
 742
 743 cleanup:
 744     CHECK_RELEASE(pDevice,              pDevice, --refcount);
 745
 746     /* Buffers */
 747     CHECK_RELEASE(pVertexBuffer,        pDevice, --refcount);
 748     CHECK_RELEASE(pIndexBuffer,         pDevice, --refcount);
 749     /* Shaders */
 750     CHECK_RELEASE(pVertexDeclaration,   pDevice, --refcount);
 751     CHECK_RELEASE(pVertexShader,        pDevice, --refcount);
 752     CHECK_RELEASE(pPixelShader,         pDevice, --refcount);
 753     /* Textures */
 754     CHECK_RELEASE(pTextureLevel,        pDevice, --refcount);
 755     CHECK_RELEASE(pCubeTexture,         pDevice, --refcount);
 756     CHECK_RELEASE(pVolumeTexture,       pDevice, --refcount);
 757     /* Surfaces */
 758     CHECK_RELEASE(pStencilSurface,      pDevice, --refcount);
 759     CHECK_RELEASE(pOffscreenSurface,    pDevice, --refcount);
 760     CHECK_RELEASE(pRenderTarget3,       pDevice, --refcount);
 761     /* Misc */
 762     CHECK_RELEASE(pStateBlock,          pDevice, --refcount);
 763     CHECK_RELEASE(pSwapChain,           pDevice, --refcount);
 764     CHECK_RELEASE(pQuery,               pDevice, --refcount);
 765     /* This will destroy device - cannot check the refcount here */
 766     if (pStateBlock1)         CHECK_RELEASE_REFCOUNT( pStateBlock1, 0);
 767
 768     if (pD3d)                 CHECK_RELEASE_REFCOUNT( pD3d, 0);
 769
 770     DestroyWindow( hwnd );
 771 }
 772
 773 static void test_cursor(void)
 774 {
 775     HRESULT                      hr;
 776     HWND                         hwnd               = NULL;
 777     IDirect3D9                  *pD3d               = NULL;
 778     IDirect3DDevice9            *pDevice            = NULL;
 779     D3DPRESENT_PARAMETERS        d3dpp;
 780     D3DDISPLAYMODE               d3ddm;
 781     CURSORINFO                   info;
 782     IDirect3DSurface9 *cursor = NULL;
 783     HCURSOR cur;
 784
 785     memset(&info, 0, sizeof(info));
 786     info.cbSize = sizeof(info);
 787     ok(GetCursorInfo(&info), "GetCursorInfo failed\n");
 788     cur = info.hCursor;
 789
 790     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
 791     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
 792     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 793     ok(hwnd != NULL, "Failed to create window\n");
 794     if (!pD3d || !hwnd) goto cleanup;
 795
 796     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 797     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 798     d3dpp.Windowed         = TRUE;
 799     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 800     d3dpp.BackBufferFormat = d3ddm.Format;
 801
 802     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 803                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 804     ok(hr == S_OK || hr == D3DERR_NOTAVAILABLE,
 805        "Failed to create IDirect3D9Device (%08x)\n", hr);
 806     if (FAILED(hr)) goto cleanup;
 807
 808     IDirect3DDevice9_CreateOffscreenPlainSurface(pDevice, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &cursor, 0);
 809     ok(cursor != NULL, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
 810
 811     /* Initially hidden */
 812     hr = IDirect3DDevice9_ShowCursor(pDevice, TRUE);
 813     ok(hr == FALSE, "IDirect3DDevice9_ShowCursor returned %08x\n", hr);
 814
 815     /* Not enabled without a surface*/
 816     hr = IDirect3DDevice9_ShowCursor(pDevice, TRUE);
 817     ok(hr == FALSE, "IDirect3DDevice9_ShowCursor returned %08x\n", hr);
 818
 819     /* Fails */
 820     hr = IDirect3DDevice9_SetCursorProperties(pDevice, 0, 0, NULL);
 821     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetCursorProperties returned %08x\n", hr);
 822
 823     hr = IDirect3DDevice9_SetCursorProperties(pDevice, 0, 0, cursor);
 824     ok(hr == D3D_OK, "IDirect3DDevice9_SetCursorProperties returned %08x\n", hr);
 825
 826     IDirect3DSurface9_Release(cursor);
 827
 828     memset(&info, 0, sizeof(info));
 829     info.cbSize = sizeof(info);
 830     ok(GetCursorInfo(&info), "GetCursorInfo failed\n");
 831     ok(info.flags & CURSOR_SHOWING, "The gdi cursor is hidden (%08x)\n", info.flags);
 832     ok(info.hCursor == cur, "The cursor handle is %p\n", info.hCursor); /* unchanged */
 833
 834     /* Still hidden */
 835     hr = IDirect3DDevice9_ShowCursor(pDevice, TRUE);
 836     ok(hr == FALSE, "IDirect3DDevice9_ShowCursor returned %08x\n", hr);
 837
 838     /* Enabled now*/
 839     hr = IDirect3DDevice9_ShowCursor(pDevice, TRUE);
 840     ok(hr == TRUE, "IDirect3DDevice9_ShowCursor returned %08x\n", hr);
 841
 842     /* GDI cursor unchanged */
 843     memset(&info, 0, sizeof(info));
 844     info.cbSize = sizeof(info);
 845     ok(GetCursorInfo(&info), "GetCursorInfo failed\n");
 846     ok(info.flags & CURSOR_SHOWING, "The gdi cursor is hidden (%08x)\n", info.flags);
 847     ok(info.hCursor == cur, "The cursor handle is %p\n", info.hCursor); /* unchanged */
 848
 849 cleanup:
 850     if (pDevice)
 851     {
 852         UINT refcount = IDirect3DDevice9_Release(pDevice);
 853         ok(!refcount, "Device has %u references left.\n", refcount);
 854     }
 855     if (pD3d) IDirect3D9_Release(pD3d);
 856     DestroyWindow( hwnd );
 857 }
 858
 859 static void test_reset(void)
 860 {
 861     HRESULT                      hr;
 862     HWND                         hwnd               = NULL;
 863     IDirect3D9                  *pD3d               = NULL;
 864     D3DPRESENT_PARAMETERS        d3dpp;
 865     D3DDISPLAYMODE               d3ddm, d3ddm2;
 866     D3DVIEWPORT9                 vp;
 867     DWORD                        width, orig_width = GetSystemMetrics(SM_CXSCREEN);
 868     DWORD                        height, orig_height = GetSystemMetrics(SM_CYSCREEN);
 869     IDirect3DSwapChain9          *pSwapchain;
 870     IDirect3DSurface9            *surface;
 871     IDirect3DTexture9            *texture;
 872     IDirect3DVertexShader9       *shader;
 873     UINT                         i, adapter_mode_count;
 874     D3DLOCKED_RECT               lockrect;
 875     IDirect3DDevice9 *device1 = NULL;
 876     IDirect3DDevice9 *device2 = NULL;
 877     D3DCAPS9 caps;
 878     struct
 879     {
 880         UINT w;
 881         UINT h;
 882     } *modes = NULL;
 883     UINT mode_count = 0;
 884
 885     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
 886     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
 887     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 888     ok(hwnd != NULL, "Failed to create window\n");
 889     if (!pD3d || !hwnd) goto cleanup;
 890
 891     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 892     adapter_mode_count = IDirect3D9_GetAdapterModeCount(pD3d, D3DADAPTER_DEFAULT, d3ddm.Format);
 893     modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*modes) * adapter_mode_count);
 894     for(i = 0; i < adapter_mode_count; ++i)
 895     {
 896         UINT j;
 897         ZeroMemory( &d3ddm2, sizeof(d3ddm2) );
 898         hr = IDirect3D9_EnumAdapterModes(pD3d, D3DADAPTER_DEFAULT, d3ddm.Format, i, &d3ddm2);
 899         ok(hr == D3D_OK, "IDirect3D9_EnumAdapterModes returned %#x\n", hr);
 900
 901         for (j = 0; j < mode_count; ++j)
 902         {
 903             if (modes[j].w == d3ddm2.Width && modes[j].h == d3ddm2.Height)
 904                 break;
 905         }
 906         if (j == mode_count)
 907         {
 908             modes[j].w = d3ddm2.Width;
 909             modes[j].h = d3ddm2.Height;
 910             ++mode_count;
 911         }
 912
 913         /* We use them as invalid modes */
 914         if((d3ddm2.Width == 801 && d3ddm2.Height == 600) ||
 915            (d3ddm2.Width == 32 && d3ddm2.Height == 32)) {
 916             skip("This system supports a screen resolution of %dx%d, not running mode tests\n",
 917                  d3ddm2.Width, d3ddm2.Height);
 918             goto cleanup;
 919         }
 920     }
 921
 922     if (mode_count < 2)
 923     {
 924         skip("Less than 2 modes supported, skipping mode tests\n");
 925         goto cleanup;
 926     }
 927
 928     i = 0;
 929     if (modes[i].w == orig_width && modes[i].h == orig_height) ++i;
 930
 931     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 932     d3dpp.Windowed         = FALSE;
 933     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 934     d3dpp.BackBufferWidth  = modes[i].w;
 935     d3dpp.BackBufferHeight = modes[i].h;
 936     d3dpp.BackBufferFormat = d3ddm.Format;
 937     d3dpp.EnableAutoDepthStencil = TRUE;
 938     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
 939
 940     hr = IDirect3D9_CreateDevice(pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
 941             hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &device1);
 942     if (FAILED(hr))
 943     {
 944         skip("could not create device, IDirect3D9_CreateDevice returned %#x\n", hr);
 945         goto cleanup;
 946     }
 947     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
 948     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after creation returned %#x\n", hr);
 949
 950     hr = IDirect3DDevice9_GetDeviceCaps(device1, &caps);
 951     ok(SUCCEEDED(hr), "GetDeviceCaps failed, hr %#x.\n", hr);
 952
 953     width = GetSystemMetrics(SM_CXSCREEN);
 954     height = GetSystemMetrics(SM_CYSCREEN);
 955     ok(width == modes[i].w, "Screen width is %u, expected %u\n", width, modes[i].w);
 956     ok(height == modes[i].h, "Screen height is %u, expected %u\n", height, modes[i].h);
 957
 958     hr = IDirect3DDevice9_GetViewport(device1, &vp);
 959     ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %08x\n", hr);
 960     if(SUCCEEDED(hr))
 961     {
 962         ok(vp.X == 0, "D3DVIEWPORT->X = %d\n", vp.X);
 963         ok(vp.Y == 0, "D3DVIEWPORT->Y = %d\n", vp.Y);
 964         ok(vp.Width == modes[i].w, "D3DVIEWPORT->Width = %u, expected %u\n", vp.Width, modes[i].w);
 965         ok(vp.Height == modes[i].h, "D3DVIEWPORT->Height = %u, expected %u\n", vp.Height, modes[i].h);
 966         ok(vp.MinZ == 0, "D3DVIEWPORT->MinZ = %f\n", vp.MinZ);
 967         ok(vp.MaxZ == 1, "D3DVIEWPORT->MaxZ = %f\n", vp.MaxZ);
 968     }
 969
 970     i = 1;
 971     vp.X = 10;
 972     vp.Y = 20;
 973     vp.MinZ = 2;
 974     vp.MaxZ = 3;
 975     hr = IDirect3DDevice9_SetViewport(device1, &vp);
 976     ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
 977
 978     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 979     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 980     d3dpp.Windowed         = FALSE;
 981     d3dpp.BackBufferWidth  = modes[i].w;
 982     d3dpp.BackBufferHeight = modes[i].h;
 983     d3dpp.BackBufferFormat = d3ddm.Format;
 984     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
 985     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
 986     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
 987     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
 988
 989     ZeroMemory(&vp, sizeof(vp));
 990     hr = IDirect3DDevice9_GetViewport(device1, &vp);
 991     ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %08x\n", hr);
 992     if(SUCCEEDED(hr))
 993     {
 994         ok(vp.X == 0, "D3DVIEWPORT->X = %d\n", vp.X);
 995         ok(vp.Y == 0, "D3DVIEWPORT->Y = %d\n", vp.Y);
 996         ok(vp.Width == modes[i].w, "D3DVIEWPORT->Width = %u, expected %u\n", vp.Width, modes[i].w);
 997         ok(vp.Height == modes[i].h, "D3DVIEWPORT->Height = %u, expected %u\n", vp.Height, modes[i].h);
 998         ok(vp.MinZ == 0, "D3DVIEWPORT->MinZ = %f\n", vp.MinZ);
 999         ok(vp.MaxZ == 1, "D3DVIEWPORT->MaxZ = %f\n", vp.MaxZ);
1000     }
1001
1002     width = GetSystemMetrics(SM_CXSCREEN);
1003     height = GetSystemMetrics(SM_CYSCREEN);
1004     ok(width == modes[i].w, "Screen width is %u, expected %u\n", width, modes[i].w);
1005     ok(height == modes[i].h, "Screen height is %u, expected %u\n", height, modes[i].h);
1006
1007     hr = IDirect3DDevice9_GetSwapChain(device1, 0, &pSwapchain);
1008     ok(hr == D3D_OK, "IDirect3DDevice9_GetSwapChain returned %08x\n", hr);
1009     if(SUCCEEDED(hr))
1010     {
1011         ZeroMemory(&d3dpp, sizeof(d3dpp));
1012         hr = IDirect3DSwapChain9_GetPresentParameters(pSwapchain, &d3dpp);
1013         ok(hr == D3D_OK, "IDirect3DSwapChain9_GetPresentParameters returned %08x\n", hr);
1014         if(SUCCEEDED(hr))
1015         {
1016             ok(d3dpp.BackBufferWidth == modes[i].w, "Back buffer width is %u, expected %u\n",
1017                     d3dpp.BackBufferWidth, modes[i].w);
1018             ok(d3dpp.BackBufferHeight == modes[i].h, "Back buffer height is %u, expected %u\n",
1019                     d3dpp.BackBufferHeight, modes[i].h);
1020         }
1021         IDirect3DSwapChain9_Release(pSwapchain);
1022     }
1023
1024     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1025     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1026     d3dpp.Windowed         = TRUE;
1027     d3dpp.BackBufferWidth  = 400;
1028     d3dpp.BackBufferHeight = 300;
1029     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1030     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1031     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1032     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1033
1034     width = GetSystemMetrics(SM_CXSCREEN);
1035     height = GetSystemMetrics(SM_CYSCREEN);
1036     ok(width == orig_width, "Screen width is %d\n", width);
1037     ok(height == orig_height, "Screen height is %d\n", height);
1038
1039     ZeroMemory(&vp, sizeof(vp));
1040     hr = IDirect3DDevice9_GetViewport(device1, &vp);
1041     ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %08x\n", hr);
1042     if(SUCCEEDED(hr))
1043     {
1044         ok(vp.X == 0, "D3DVIEWPORT->X = %d\n", vp.X);
1045         ok(vp.Y == 0, "D3DVIEWPORT->Y = %d\n", vp.Y);
1046         ok(vp.Width == 400, "D3DVIEWPORT->Width = %d\n", vp.Width);
1047         ok(vp.Height == 300, "D3DVIEWPORT->Height = %d\n", vp.Height);
1048         ok(vp.MinZ == 0, "D3DVIEWPORT->MinZ = %f\n", vp.MinZ);
1049         ok(vp.MaxZ == 1, "D3DVIEWPORT->MaxZ = %f\n", vp.MaxZ);
1050     }
1051
1052     hr = IDirect3DDevice9_GetSwapChain(device1, 0, &pSwapchain);
1053     ok(hr == D3D_OK, "IDirect3DDevice9_GetSwapChain returned %08x\n", hr);
1054     if(SUCCEEDED(hr))
1055     {
1056         ZeroMemory(&d3dpp, sizeof(d3dpp));
1057         hr = IDirect3DSwapChain9_GetPresentParameters(pSwapchain, &d3dpp);
1058         ok(hr == D3D_OK, "IDirect3DSwapChain9_GetPresentParameters returned %08x\n", hr);
1059         if(SUCCEEDED(hr))
1060         {
1061             ok(d3dpp.BackBufferWidth == 400, "Back buffer width is %d\n", d3dpp.BackBufferWidth);
1062             ok(d3dpp.BackBufferHeight == 300, "Back buffer height is %d\n", d3dpp.BackBufferHeight);
1063         }
1064         IDirect3DSwapChain9_Release(pSwapchain);
1065     }
1066
1067     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1068     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1069     d3dpp.Windowed         = TRUE;
1070     d3dpp.BackBufferWidth  = 400;
1071     d3dpp.BackBufferHeight = 300;
1072
1073     /* _Reset fails if there is a resource in the default pool */
1074     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device1, 16, 16, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &surface, NULL);
1075     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned %08x\n", hr);
1076     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1077     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1078     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1079     ok(hr == D3DERR_DEVICENOTRESET, "IDirect3DDevice9_TestCooperativeLevel after a failed reset returned %#x\n", hr);
1080     IDirect3DSurface9_Release(surface);
1081     /* Reset again to get the device out of the lost state */
1082     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1083     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1084     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1085     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1086
1087     if (caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
1088     {
1089         IDirect3DVolumeTexture9 *volume_texture;
1090
1091         hr = IDirect3DDevice9_CreateVolumeTexture(device1, 16, 16, 4, 1, 0,
1092                 D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &volume_texture, NULL);
1093         ok(SUCCEEDED(hr), "CreateVolumeTexture failed, hr %#x.\n", hr);
1094         hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1095         ok(hr == D3DERR_INVALIDCALL, "Reset returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
1096         hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1097         ok(hr == D3DERR_DEVICENOTRESET, "TestCooperativeLevel returned %#x, expected %#x.\n",
1098                 hr, D3DERR_DEVICENOTRESET);
1099         IDirect3DVolumeTexture9_Release(volume_texture);
1100         hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1101         ok(SUCCEEDED(hr), "Reset failed, hr %#x.\n", hr);
1102         hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1103         ok(SUCCEEDED(hr), "TestCooperativeLevel failed, hr %#x.\n", hr);
1104     }
1105     else
1106     {
1107         skip("Volume textures not supported.\n");
1108     }
1109
1110     /* Scratch, sysmem and managed pools are fine */
1111     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device1, 16, 16, D3DFMT_R5G6B5, D3DPOOL_SCRATCH, &surface, NULL);
1112     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned %08x\n", hr);
1113     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1114     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1115     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1116     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1117     IDirect3DSurface9_Release(surface);
1118
1119     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device1, 16, 16,
1120             D3DFMT_R5G6B5, D3DPOOL_SYSTEMMEM, &surface, NULL);
1121     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned %08x\n", hr);
1122     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1123     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1124     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1125     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1126     IDirect3DSurface9_Release(surface);
1127
1128     /* The depth stencil should get reset to the auto depth stencil when present. */
1129     hr = IDirect3DDevice9_SetDepthStencilSurface(device1, NULL);
1130     ok(hr == D3D_OK, "SetDepthStencilSurface failed with 0x%08x\n", hr);
1131
1132     hr = IDirect3DDevice9_GetDepthStencilSurface(device1, &surface);
1133     ok(hr == D3DERR_NOTFOUND, "GetDepthStencilSurface returned 0x%08x, expected D3DERR_NOTFOUND\n", hr);
1134     ok(surface == NULL, "Depth stencil should be NULL\n");
1135
1136     d3dpp.EnableAutoDepthStencil = TRUE;
1137     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
1138     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1139     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with 0x%08x\n", hr);
1140
1141     hr = IDirect3DDevice9_GetDepthStencilSurface(device1, &surface);
1142     ok(hr == D3D_OK, "GetDepthStencilSurface failed with 0x%08x\n", hr);
1143     ok(surface != NULL, "Depth stencil should not be NULL\n");
1144     if (surface) IDirect3DSurface9_Release(surface);
1145
1146     d3dpp.EnableAutoDepthStencil = FALSE;
1147     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1148     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with 0x%08x\n", hr);
1149
1150     hr = IDirect3DDevice9_GetDepthStencilSurface(device1, &surface);
1151     ok(hr == D3DERR_NOTFOUND, "GetDepthStencilSurface returned 0x%08x, expected D3DERR_NOTFOUND\n", hr);
1152     ok(surface == NULL, "Depth stencil should be NULL\n");
1153
1154     /* Will a sysmem or scratch survive while locked */
1155     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device1, 16, 16,
1156             D3DFMT_R5G6B5, D3DPOOL_SYSTEMMEM, &surface, NULL);
1157     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned %08x\n", hr);
1158     hr = IDirect3DSurface9_LockRect(surface, &lockrect, NULL, D3DLOCK_DISCARD);
1159     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned %08x\n", hr);
1160     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1161     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1162     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1163     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1164     IDirect3DSurface9_UnlockRect(surface);
1165     IDirect3DSurface9_Release(surface);
1166
1167     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device1, 16, 16, D3DFMT_R5G6B5, D3DPOOL_SCRATCH, &surface, NULL);
1168     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned %08x\n", hr);
1169     hr = IDirect3DSurface9_LockRect(surface, &lockrect, NULL, D3DLOCK_DISCARD);
1170     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned %08x\n", hr);
1171     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1172     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1173     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1174     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1175     IDirect3DSurface9_UnlockRect(surface);
1176     IDirect3DSurface9_Release(surface);
1177
1178     hr = IDirect3DDevice9_CreateTexture(device1, 16, 16, 0, 0, D3DFMT_R5G6B5, D3DPOOL_MANAGED, &texture, NULL);
1179     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
1180     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1181     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1182     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1183     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1184     IDirect3DTexture9_Release(texture);
1185
1186     /* A reference held to an implicit surface causes failures as well */
1187     hr = IDirect3DDevice9_GetBackBuffer(device1, 0, 0, D3DBACKBUFFER_TYPE_MONO, &surface);
1188     ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer returned %08x\n", hr);
1189     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1190     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1191     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1192     ok(hr == D3DERR_DEVICENOTRESET, "IDirect3DDevice9_TestCooperativeLevel after a failed reset returned %#x\n", hr);
1193     IDirect3DSurface9_Release(surface);
1194     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1195     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1196     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1197     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
1198
1199     /* Shaders are fine as well */
1200     hr = IDirect3DDevice9_CreateVertexShader(device1, simple_vs, &shader);
1201     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
1202     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1203     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
1204     IDirect3DVertexShader9_Release(shader);
1205
1206     /* Try setting invalid modes */
1207     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1208     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1209     d3dpp.Windowed         = FALSE;
1210     d3dpp.BackBufferWidth  = 32;
1211     d3dpp.BackBufferHeight = 32;
1212     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1213     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Reset to w=32, h=32, windowed=FALSE failed with %08x\n", hr);
1214     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1215     ok(hr == D3DERR_DEVICENOTRESET, "IDirect3DDevice9_TestCooperativeLevel after a failed reset returned %#x\n", hr);
1216
1217     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1218     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1219     d3dpp.Windowed         = FALSE;
1220     d3dpp.BackBufferWidth  = 801;
1221     d3dpp.BackBufferHeight = 600;
1222     hr = IDirect3DDevice9_Reset(device1, &d3dpp);
1223     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Reset to w=801, h=600, windowed=FALSE failed with %08x\n", hr);
1224     hr = IDirect3DDevice9_TestCooperativeLevel(device1);
1225     ok(hr == D3DERR_DEVICENOTRESET, "IDirect3DDevice9_TestCooperativeLevel after a failed reset returned %#x\n", hr);
1226
1227     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
1228
1229     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1230     d3dpp.Windowed         = TRUE;
1231     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1232     d3dpp.BackBufferFormat = d3ddm.Format;
1233     d3dpp.EnableAutoDepthStencil = FALSE;
1234     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
1235
1236     hr = IDirect3D9_CreateDevice(pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
1237             hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &device2);
1238     if (FAILED(hr))
1239     {
1240         skip("could not create device, IDirect3D9_CreateDevice returned %#x\n", hr);
1241         goto cleanup;
1242     }
1243
1244     hr = IDirect3DDevice9_TestCooperativeLevel(device2);
1245     ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after creation returned %#x\n", hr);
1246
1247     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1248     d3dpp.Windowed         = TRUE;
1249     d3dpp.BackBufferWidth  = 400;
1250     d3dpp.BackBufferHeight = 300;
1251     d3dpp.EnableAutoDepthStencil = TRUE;
1252     d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
1253
1254     hr = IDirect3DDevice9_Reset(device2, &d3dpp);
1255     ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with 0x%08x\n", hr);
1256
1257     if (FAILED(hr)) goto cleanup;
1258
1259     hr = IDirect3DDevice9_GetDepthStencilSurface(device2, &surface);
1260     ok(hr == D3D_OK, "GetDepthStencilSurface failed with 0x%08x\n", hr);
1261     ok(surface != NULL, "Depth stencil should not be NULL\n");
1262     if (surface) IDirect3DSurface9_Release(surface);
1263
1264 cleanup:
1265     HeapFree(GetProcessHeap(), 0, modes);
1266     if (device2)
1267     {
1268         UINT refcount = IDirect3DDevice9_Release(device2);
1269         ok(!refcount, "Device has %u references left.\n", refcount);
1270     }
1271     if (device1)
1272     {
1273         UINT refcount = IDirect3DDevice9_Release(device1);
1274         ok(!refcount, "Device has %u references left.\n", refcount);
1275     }
1276     if (pD3d) IDirect3D9_Release(pD3d);
1277     if (hwnd) DestroyWindow(hwnd);
1278 }
1279
1280 /* Test adapter display modes */
1281 static void test_display_modes(void)
1282 {
1283     D3DDISPLAYMODE dmode;
1284     IDirect3D9 *pD3d;
1285
1286     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
1287     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
1288     if(!pD3d) return;
1289
1290 #define TEST_FMT(x,r) do { \
1291     HRESULT res = IDirect3D9_EnumAdapterModes(pD3d, 0, (x), 0, &dmode); \
1292     ok(res==(r), "EnumAdapterModes("#x") did not return "#r" (got %08x)!\n", res); \
1293 } while(0)
1294
1295     TEST_FMT(D3DFMT_R8G8B8, D3DERR_INVALIDCALL);
1296     TEST_FMT(D3DFMT_A8R8G8B8, D3DERR_INVALIDCALL);
1297     TEST_FMT(D3DFMT_X8B8G8R8, D3DERR_INVALIDCALL);
1298     /* D3DFMT_R5G6B5 */
1299     TEST_FMT(D3DFMT_X1R5G5B5, D3DERR_INVALIDCALL);
1300     TEST_FMT(D3DFMT_A1R5G5B5, D3DERR_INVALIDCALL);
1301     TEST_FMT(D3DFMT_A4R4G4B4, D3DERR_INVALIDCALL);
1302     TEST_FMT(D3DFMT_R3G3B2, D3DERR_INVALIDCALL);
1303     TEST_FMT(D3DFMT_A8, D3DERR_INVALIDCALL);
1304     TEST_FMT(D3DFMT_A8R3G3B2, D3DERR_INVALIDCALL);
1305     TEST_FMT(D3DFMT_X4R4G4B4, D3DERR_INVALIDCALL);
1306     TEST_FMT(D3DFMT_A2B10G10R10, D3DERR_INVALIDCALL);
1307     TEST_FMT(D3DFMT_A8B8G8R8, D3DERR_INVALIDCALL);
1308     TEST_FMT(D3DFMT_X8B8G8R8, D3DERR_INVALIDCALL);
1309     TEST_FMT(D3DFMT_G16R16, D3DERR_INVALIDCALL);
1310     TEST_FMT(D3DFMT_A16B16G16R16, D3DERR_INVALIDCALL);
1311
1312     TEST_FMT(D3DFMT_A8P8, D3DERR_INVALIDCALL);
1313     TEST_FMT(D3DFMT_P8, D3DERR_INVALIDCALL);
1314
1315     TEST_FMT(D3DFMT_L8, D3DERR_INVALIDCALL);
1316     TEST_FMT(D3DFMT_A8L8, D3DERR_INVALIDCALL);
1317     TEST_FMT(D3DFMT_A4L4, D3DERR_INVALIDCALL);
1318
1319     TEST_FMT(D3DFMT_V8U8, D3DERR_INVALIDCALL);
1320     TEST_FMT(D3DFMT_L6V5U5, D3DERR_INVALIDCALL);
1321     TEST_FMT(D3DFMT_X8L8V8U8, D3DERR_INVALIDCALL);
1322     TEST_FMT(D3DFMT_Q8W8V8U8, D3DERR_INVALIDCALL);
1323     TEST_FMT(D3DFMT_V16U16, D3DERR_INVALIDCALL);
1324     TEST_FMT(D3DFMT_A2W10V10U10, D3DERR_INVALIDCALL);
1325
1326     TEST_FMT(D3DFMT_UYVY, D3DERR_INVALIDCALL);
1327     TEST_FMT(D3DFMT_YUY2, D3DERR_INVALIDCALL);
1328     TEST_FMT(D3DFMT_DXT1, D3DERR_INVALIDCALL);
1329     TEST_FMT(D3DFMT_DXT2, D3DERR_INVALIDCALL);
1330     TEST_FMT(D3DFMT_DXT3, D3DERR_INVALIDCALL);
1331     TEST_FMT(D3DFMT_DXT4, D3DERR_INVALIDCALL);
1332     TEST_FMT(D3DFMT_DXT5, D3DERR_INVALIDCALL);
1333     TEST_FMT(D3DFMT_MULTI2_ARGB8, D3DERR_INVALIDCALL);
1334     TEST_FMT(D3DFMT_G8R8_G8B8, D3DERR_INVALIDCALL);
1335     TEST_FMT(D3DFMT_R8G8_B8G8, D3DERR_INVALIDCALL);
1336
1337     TEST_FMT(D3DFMT_D16_LOCKABLE, D3DERR_INVALIDCALL);
1338     TEST_FMT(D3DFMT_D32, D3DERR_INVALIDCALL);
1339     TEST_FMT(D3DFMT_D15S1, D3DERR_INVALIDCALL);
1340     TEST_FMT(D3DFMT_D24S8, D3DERR_INVALIDCALL);
1341     TEST_FMT(D3DFMT_D24X8, D3DERR_INVALIDCALL);
1342     TEST_FMT(D3DFMT_D24X4S4, D3DERR_INVALIDCALL);
1343     TEST_FMT(D3DFMT_D16, D3DERR_INVALIDCALL);
1344     TEST_FMT(D3DFMT_L16, D3DERR_INVALIDCALL);
1345     TEST_FMT(D3DFMT_D32F_LOCKABLE, D3DERR_INVALIDCALL);
1346     TEST_FMT(D3DFMT_D24FS8, D3DERR_INVALIDCALL);
1347
1348     TEST_FMT(D3DFMT_VERTEXDATA, D3DERR_INVALIDCALL);
1349     TEST_FMT(D3DFMT_INDEX16, D3DERR_INVALIDCALL);
1350     TEST_FMT(D3DFMT_INDEX32, D3DERR_INVALIDCALL);
1351     TEST_FMT(D3DFMT_Q16W16V16U16, D3DERR_INVALIDCALL);
1352     /* Floating point formats */
1353     TEST_FMT(D3DFMT_R16F, D3DERR_INVALIDCALL);
1354     TEST_FMT(D3DFMT_G16R16F, D3DERR_INVALIDCALL);
1355     TEST_FMT(D3DFMT_A16B16G16R16F, D3DERR_INVALIDCALL);
1356
1357     /* IEEE formats */
1358     TEST_FMT(D3DFMT_R32F, D3DERR_INVALIDCALL);
1359     TEST_FMT(D3DFMT_G32R32F, D3DERR_INVALIDCALL);
1360     TEST_FMT(D3DFMT_A32B32G32R32F, D3DERR_INVALIDCALL);
1361
1362     TEST_FMT(D3DFMT_CxV8U8, D3DERR_INVALIDCALL);
1363
1364     TEST_FMT(0, D3DERR_INVALIDCALL);
1365
1366     IDirect3D9_Release(pD3d);
1367 }
1368
1369 static void test_scene(void)
1370 {
1371     HRESULT                      hr;
1372     HWND                         hwnd               = NULL;
1373     IDirect3D9                  *pD3d               = NULL;
1374     IDirect3DDevice9            *pDevice            = NULL;
1375     D3DPRESENT_PARAMETERS        d3dpp;
1376     D3DDISPLAYMODE               d3ddm;
1377     IDirect3DSurface9            *pSurface1 = NULL, *pSurface2 = NULL, *pSurface3 = NULL, *pRenderTarget = NULL;
1378     IDirect3DSurface9            *pBackBuffer = NULL, *pDepthStencil = NULL;
1379     RECT rect = {0, 0, 128, 128};
1380     D3DCAPS9                     caps;
1381
1382     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
1383     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
1384     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1385     ok(hwnd != NULL, "Failed to create window\n");
1386     if (!pD3d || !hwnd) goto cleanup;
1387
1388     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
1389     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1390     d3dpp.Windowed         = TRUE;
1391     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1392     d3dpp.BackBufferWidth  = 800;
1393     d3dpp.BackBufferHeight = 600;
1394     d3dpp.BackBufferFormat = d3ddm.Format;
1395     d3dpp.EnableAutoDepthStencil = TRUE;
1396     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1397
1398     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1399                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1400     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D9_CreateDevice failed with %08x\n", hr);
1401     if(!pDevice)
1402     {
1403         skip("Failed to create a d3d device\n");
1404         goto cleanup;
1405     }
1406
1407     /* Get the caps, they will be needed to tell if an operation is supposed to be valid */
1408     memset(&caps, 0, sizeof(caps));
1409     hr = IDirect3DDevice9_GetDeviceCaps(pDevice, &caps);
1410     ok(hr == D3D_OK, "IDirect3DDevice9_GetCaps failed with %08x\n", hr);
1411     if(FAILED(hr)) goto cleanup;
1412
1413     /* Test an EndScene without BeginScene. Should return an error */
1414     hr = IDirect3DDevice9_EndScene(pDevice);
1415     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_EndScene returned %08x\n", hr);
1416
1417     /* Test a normal BeginScene / EndScene pair, this should work */
1418     hr = IDirect3DDevice9_BeginScene(pDevice);
1419     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
1420     if(SUCCEEDED(hr))
1421     {
1422         hr = IDirect3DDevice9_EndScene(pDevice);
1423         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
1424     }
1425
1426     /* Test another EndScene without having begun a new scene. Should return an error */
1427     hr = IDirect3DDevice9_EndScene(pDevice);
1428     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_EndScene returned %08x\n", hr);
1429
1430     /* Two nested BeginScene and EndScene calls */
1431     hr = IDirect3DDevice9_BeginScene(pDevice);
1432     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
1433     hr = IDirect3DDevice9_BeginScene(pDevice);
1434     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
1435     hr = IDirect3DDevice9_EndScene(pDevice);
1436     ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
1437     hr = IDirect3DDevice9_EndScene(pDevice);
1438     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_EndScene returned %08x\n", hr);
1439
1440     /* Create some surfaces to test stretchrect between the scenes */
1441     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(pDevice, 128, 128, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pSurface1, NULL);
1442     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
1443     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(pDevice, 128, 128, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pSurface2, NULL);
1444     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
1445     hr = IDirect3DDevice9_CreateDepthStencilSurface(pDevice, 800, 600, D3DFMT_D16, D3DMULTISAMPLE_NONE, 0, FALSE, &pSurface3, NULL);
1446     ok(hr == D3D_OK, "IDirect3DDevice9_CreateDepthStencilSurface failed with %08x\n", hr);
1447     hr = IDirect3DDevice9_CreateRenderTarget(pDevice, 128, 128, d3ddm.Format, D3DMULTISAMPLE_NONE, 0, FALSE, &pRenderTarget, NULL);
1448     ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget failed with %08x\n", hr);
1449
1450     hr = IDirect3DDevice9_GetBackBuffer(pDevice, 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
1451     ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed with %08x\n", hr);
1452     hr = IDirect3DDevice9_GetDepthStencilSurface(pDevice, &pDepthStencil);
1453     ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed with %08x\n", hr);
1454
1455     /* First make sure a simple StretchRect call works */
1456     if(pSurface1 && pSurface2) {
1457         hr = IDirect3DDevice9_StretchRect(pDevice, pSurface1, NULL, pSurface2, NULL, 0);
1458         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
1459     }
1460     if(pBackBuffer && pRenderTarget) {
1461         hr = IDirect3DDevice9_StretchRect(pDevice, pBackBuffer, &rect, pRenderTarget, NULL, 0);
1462         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
1463     }
1464     if(pDepthStencil && pSurface3) {
1465         HRESULT expected;
1466         if(0) /* Disabled for now because it crashes in wine */ {
1467             expected = caps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES ? D3D_OK : D3DERR_INVALIDCALL;
1468             hr = IDirect3DDevice9_StretchRect(pDevice, pDepthStencil, NULL, pSurface3, NULL, 0);
1469             ok( hr == expected, "IDirect3DDevice9_StretchRect returned %08x, expected %08x\n", hr, expected);
1470         }
1471     }
1472
1473     /* Now try it in a BeginScene - EndScene pair. Seems to be allowed in a beginScene - Endscene pair
1474      * with normal surfaces and render targets, but not depth stencil surfaces.
1475      */
1476     hr = IDirect3DDevice9_BeginScene(pDevice);
1477     ok( hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
1478
1479     if(pSurface1 && pSurface2)
1480     {
1481         hr = IDirect3DDevice9_StretchRect(pDevice, pSurface1, NULL, pSurface2, NULL, 0);
1482         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
1483     }
1484     if(pBackBuffer && pRenderTarget)
1485     {
1486         hr = IDirect3DDevice9_StretchRect(pDevice, pBackBuffer, &rect, pRenderTarget, NULL, 0);
1487         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
1488     }
1489     if(pDepthStencil && pSurface3)
1490     {
1491         /* This is supposed to fail inside a BeginScene - EndScene pair. */
1492         hr = IDirect3DDevice9_StretchRect(pDevice, pDepthStencil, NULL, pSurface3, NULL, 0);
1493         ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect returned %08x, expected D3DERR_INVALIDCALL\n", hr);
1494     }
1495
1496     hr = IDirect3DDevice9_EndScene(pDevice);
1497     ok( hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
1498
1499     /* Does a SetRenderTarget influence BeginScene / EndScene ?
1500      * Set a new render target, then see if it started a new scene. Flip the rt back and see if that maybe
1501      * ended the scene. Expected result is that the scene is not affected by SetRenderTarget
1502      */
1503     hr = IDirect3DDevice9_SetRenderTarget(pDevice, 0, pRenderTarget);
1504     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
1505     hr = IDirect3DDevice9_BeginScene(pDevice);
1506     ok( hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
1507     hr = IDirect3DDevice9_SetRenderTarget(pDevice, 0, pBackBuffer);
1508     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
1509     hr = IDirect3DDevice9_EndScene(pDevice);
1510     ok( hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
1511
1512 cleanup:
1513     if(pRenderTarget) IDirect3DSurface9_Release(pRenderTarget);
1514     if(pDepthStencil) IDirect3DSurface9_Release(pDepthStencil);
1515     if(pBackBuffer) IDirect3DSurface9_Release(pBackBuffer);
1516     if(pSurface1) IDirect3DSurface9_Release(pSurface1);
1517     if(pSurface2) IDirect3DSurface9_Release(pSurface2);
1518     if(pSurface3) IDirect3DSurface9_Release(pSurface3);
1519     if (pDevice)
1520     {
1521         UINT refcount = IDirect3DDevice9_Release(pDevice);
1522         ok(!refcount, "Device has %u references left.\n", refcount);
1523     }
1524     if (pD3d) IDirect3D9_Release(pD3d);
1525     if(hwnd) DestroyWindow(hwnd);
1526 }
1527
1528 static void test_limits(void)
1529 {
1530     HRESULT                      hr;
1531     HWND                         hwnd               = NULL;
1532     IDirect3D9                  *pD3d               = NULL;
1533     IDirect3DDevice9            *pDevice            = NULL;
1534     D3DPRESENT_PARAMETERS        d3dpp;
1535     D3DDISPLAYMODE               d3ddm;
1536     IDirect3DTexture9           *pTexture           = NULL;
1537     int i;
1538
1539     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
1540     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
1541     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1542     ok(hwnd != NULL, "Failed to create window\n");
1543     if (!pD3d || !hwnd) goto cleanup;
1544
1545     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
1546     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1547     d3dpp.Windowed         = TRUE;
1548     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1549     d3dpp.BackBufferWidth  = 800;
1550     d3dpp.BackBufferHeight = 600;
1551     d3dpp.BackBufferFormat = d3ddm.Format;
1552     d3dpp.EnableAutoDepthStencil = TRUE;
1553     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1554
1555     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1556                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1557     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D9_CreateDevice failed with %08x\n", hr);
1558     if(!pDevice)
1559     {
1560         skip("Failed to create a d3d device\n");
1561         goto cleanup;
1562     }
1563
1564     hr = IDirect3DDevice9_CreateTexture(pDevice, 16, 16, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pTexture, NULL);
1565     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
1566     if(!pTexture) goto cleanup;
1567
1568     /* There are 16 pixel samplers. We should be able to access all of them */
1569     for(i = 0; i < 16; i++) {
1570         hr = IDirect3DDevice9_SetTexture(pDevice, i, (IDirect3DBaseTexture9 *) pTexture);
1571         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture for sampler %d failed with %08x\n", i, hr);
1572         hr = IDirect3DDevice9_SetTexture(pDevice, i, NULL);
1573         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture for sampler %d failed with %08x\n", i, hr);
1574         hr = IDirect3DDevice9_SetSamplerState(pDevice, i, D3DSAMP_SRGBTEXTURE, TRUE);
1575         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState for sampler %d failed with %08x\n", i, hr);
1576     }
1577
1578     /* Now test all 8 textures stage states */
1579     for(i = 0; i < 8; i++) {
1580         hr = IDirect3DDevice9_SetTextureStageState(pDevice, i, D3DTSS_COLOROP, D3DTOP_ADD);
1581         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState for texture %d failed with %08x\n", i, hr);
1582     }
1583
1584     /* Investigations show that accessing higher samplers / textures stage states does not return an error either. Writing
1585      * to too high samplers(approximately sampler 40) causes memory corruption in windows, so there is no bounds checking
1586      * but how do I test that?
1587      */
1588 cleanup:
1589     if(pTexture) IDirect3DTexture9_Release(pTexture);
1590     if (pDevice)
1591     {
1592         UINT refcount = IDirect3D9_Release(pDevice);
1593         ok(!refcount, "Device has %u references left.\n", refcount);
1594     }
1595     if (pD3d) IDirect3D9_Release(pD3d);
1596     if(hwnd) DestroyWindow(hwnd);
1597 }
1598
1599 static void test_depthstenciltest(void)
1600 {
1601     HRESULT                      hr;
1602     HWND                         hwnd               = NULL;
1603     IDirect3D9                  *pD3d               = NULL;
1604     IDirect3DDevice9            *pDevice            = NULL;
1605     D3DPRESENT_PARAMETERS        d3dpp;
1606     D3DDISPLAYMODE               d3ddm;
1607     IDirect3DSurface9           *pDepthStencil           = NULL;
1608     IDirect3DSurface9           *pDepthStencil2          = NULL;
1609     DWORD                        state;
1610
1611     pD3d = pDirect3DCreate9( D3D_SDK_VERSION );
1612     ok(pD3d != NULL, "Failed to create IDirect3D9 object\n");
1613     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1614     ok(hwnd != NULL, "Failed to create window\n");
1615     if (!pD3d || !hwnd) goto cleanup;
1616
1617     IDirect3D9_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
1618     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1619     d3dpp.Windowed         = TRUE;
1620     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1621     d3dpp.BackBufferWidth  = 800;
1622     d3dpp.BackBufferHeight = 600;
1623     d3dpp.BackBufferFormat = d3ddm.Format;
1624     d3dpp.EnableAutoDepthStencil = TRUE;
1625     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1626
1627     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1628                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1629     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D9_CreateDevice failed with %08x\n", hr);
1630     if(!pDevice)
1631     {
1632         skip("Failed to create a d3d device\n");
1633         goto cleanup;
1634     }
1635
1636     hr = IDirect3DDevice9_GetDepthStencilSurface(pDevice, &pDepthStencil);
1637     ok(hr == D3D_OK && pDepthStencil != NULL, "IDirect3DDevice9_GetDepthStencilSurface failed with %08x\n", hr);
1638
1639     /* Try to clear */
1640     hr = IDirect3DDevice9_Clear(pDevice, 0, NULL, D3DCLEAR_ZBUFFER, 0x00000000, 1.0, 0);
1641     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
1642
1643     hr = IDirect3DDevice9_SetDepthStencilSurface(pDevice, NULL);
1644     ok(hr == D3D_OK, "IDirect3DDevice9_SetDepthStencilSurface failed with %08x\n", hr);
1645
1646     /* Check if the set buffer is returned on a get. WineD3D had a bug with that once, prevent it from coming back */
1647     hr = IDirect3DDevice9_GetDepthStencilSurface(pDevice, &pDepthStencil2);
1648     ok(hr == D3DERR_NOTFOUND && pDepthStencil2 == NULL, "IDirect3DDevice9_GetDepthStencilSurface failed with %08x\n", hr);
1649     if(pDepthStencil2) IDirect3DSurface9_Release(pDepthStencil2);
1650
1651     /* This left the render states untouched! */
1652     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_ZENABLE, &state);
1653     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1654     ok(state == D3DZB_TRUE, "D3DRS_ZENABLE is %s\n", state == D3DZB_FALSE ? "D3DZB_FALSE" : (state == D3DZB_TRUE ? "D3DZB_TRUE" : "D3DZB_USEW"));
1655     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_ZWRITEENABLE, &state);
1656     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1657     ok(state == TRUE, "D3DRS_ZWRITEENABLE is %s\n", state ? "TRUE" : "FALSE");
1658     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_STENCILENABLE, &state);
1659     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1660     ok(state == FALSE, "D3DRS_STENCILENABLE is %s\n", state ? "TRUE" : "FALSE");
1661     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_STENCILWRITEMASK, &state);
1662     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1663     ok(state == 0xffffffff, "D3DRS_STENCILWRITEMASK is 0x%08x\n", state);
1664
1665     /* This is supposed to fail now */
1666     hr = IDirect3DDevice9_Clear(pDevice, 0, NULL, D3DCLEAR_ZBUFFER, 0x00000000, 1.0, 0);
1667     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %08x\n", hr);
1668
1669     hr = IDirect3DDevice9_SetRenderState(pDevice, D3DRS_ZENABLE, D3DZB_FALSE);
1670     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
1671
1672     hr = IDirect3DDevice9_SetDepthStencilSurface(pDevice, pDepthStencil);
1673     ok(hr == D3D_OK, "IDirect3DDevice9_SetDepthStencilSurface failed with %08x\n", hr);
1674
1675     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_ZENABLE, &state);
1676     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1677     ok(state == D3DZB_FALSE, "D3DRS_ZENABLE is %s\n", state == D3DZB_FALSE ? "D3DZB_FALSE" : (state == D3DZB_TRUE ? "D3DZB_TRUE" : "D3DZB_USEW"));
1678
1679     /* Now it works again */
1680     hr = IDirect3DDevice9_Clear(pDevice, 0, NULL, D3DCLEAR_ZBUFFER, 0x00000000, 1.0, 0);
1681     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
1682
1683     if(pDepthStencil) IDirect3DSurface9_Release(pDepthStencil);
1684     if(pDevice) IDirect3D9_Release(pDevice);
1685
1686     /* Now see if autodepthstencil disable is honored. First, without a format set */
1687     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1688     d3dpp.Windowed         = TRUE;
1689     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1690     d3dpp.BackBufferWidth  = 800;
1691     d3dpp.BackBufferHeight = 600;
1692     d3dpp.BackBufferFormat = d3ddm.Format;
1693     d3dpp.EnableAutoDepthStencil = FALSE;
1694     d3dpp.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
1695
1696     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1697                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1698     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D9_CreateDevice failed with %08x\n", hr);
1699     if(!pDevice)
1700     {
1701         skip("Failed to create a d3d device\n");
1702         goto cleanup;
1703     }
1704
1705     pDepthStencil = NULL;
1706     hr = IDirect3DDevice9_GetDepthStencilSurface(pDevice, &pDepthStencil);
1707     ok(hr == D3DERR_NOTFOUND && pDepthStencil == NULL, "IDirect3DDevice9_GetDepthStencilSurface returned %08x, surface = %p\n", hr, pDepthStencil);
1708     if(pDepthStencil) {
1709         IDirect3DSurface9_Release(pDepthStencil);
1710         pDepthStencil = NULL;
1711     }
1712
1713     /* Check the depth test state */
1714     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_ZENABLE, &state);
1715     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1716     ok(state == D3DZB_FALSE, "D3DRS_ZENABLE is %s\n", state == D3DZB_FALSE ? "D3DZB_FALSE" : (state == D3DZB_TRUE ? "D3DZB_TRUE" : "D3DZB_USEW"));
1717
1718     if(pDevice) IDirect3D9_Release(pDevice);
1719
1720     /* Next, try EnableAutoDepthStencil FALSE with a depth stencil format set */
1721     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1722     d3dpp.Windowed         = TRUE;
1723     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1724     d3dpp.BackBufferWidth  = 800;
1725     d3dpp.BackBufferHeight = 600;
1726     d3dpp.BackBufferFormat = d3ddm.Format;
1727     d3dpp.EnableAutoDepthStencil = FALSE;
1728     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1729
1730     hr = IDirect3D9_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1731                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1732     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D9_CreateDevice failed with %08x\n", hr);
1733     if(!pDevice)
1734     {
1735         skip("Failed to create a d3d device\n");
1736         goto cleanup;
1737     }
1738
1739     pDepthStencil = NULL;
1740     hr = IDirect3DDevice9_GetDepthStencilSurface(pDevice, &pDepthStencil);
1741     ok(hr == D3DERR_NOTFOUND && pDepthStencil == NULL, "IDirect3DDevice9_GetDepthStencilSurface returned %08x, surface = %p\n", hr, pDepthStencil);
1742     if(pDepthStencil) {
1743         IDirect3DSurface9_Release(pDepthStencil);
1744         pDepthStencil = NULL;
1745     }
1746
1747     hr = IDirect3DDevice9_GetRenderState(pDevice, D3DRS_ZENABLE, &state);
1748     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
1749     ok(state == D3DZB_FALSE, "D3DRS_ZENABLE is %s\n", state == D3DZB_FALSE ? "D3DZB_FALSE" : (state == D3DZB_TRUE ? "D3DZB_TRUE" : "D3DZB_USEW"));
1750
1751 cleanup:
1752     if(pDepthStencil) IDirect3DSurface9_Release(pDepthStencil);
1753     if (pDevice)
1754     {
1755         UINT refcount = IDirect3D9_Release(pDevice);
1756         ok(!refcount, "Device has %u references left.\n", refcount);
1757     }
1758     if (pD3d) IDirect3D9_Release(pD3d);
1759     if(hwnd) DestroyWindow(hwnd);
1760 }
1761
1762 static void test_get_rt(void)
1763 {
1764     IDirect3DSurface9 *backbuffer, *rt;
1765     IDirect3DDevice9 *device;
1766     IDirect3D9 *d3d9;
1767     D3DCAPS9 caps;
1768     HWND window;
1769     HRESULT hr;
1770     ULONG ref;
1771     UINT i;
1772
1773     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
1774     {
1775         skip("Failed to create IDirect3D9 object, skipping tests.\n");
1776         return;
1777     }
1778
1779     window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
1780             0, 0, 128, 128, 0, 0, 0, 0);
1781     device = create_device(d3d9, window, window, TRUE);
1782     if (!device)
1783     {
1784         skip("Failed to create a D3D device, skipping tests.\n");
1785         goto done;
1786     }
1787
1788     hr = IDirect3DDevice9_GetRenderTarget(device, 0, &backbuffer);
1789     ok(SUCCEEDED(hr), "Failed to get backbuffer, hr %#x.\n", hr);
1790     ok(!!backbuffer, "Got a NULL backbuffer.\n");
1791
1792     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
1793     ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
1794
1795     for (i = 1; i < caps.NumSimultaneousRTs; ++i)
1796     {
1797         rt = backbuffer;
1798         hr = IDirect3DDevice9_GetRenderTarget(device, i, &rt);
1799         ok(hr == D3DERR_NOTFOUND, "IDirect3DDevice9_GetRenderTarget returned %#x.\n", hr);
1800         ok(!rt, "Got rt %p.\n", rt);
1801     }
1802
1803     IDirect3DSurface9_Release(backbuffer);
1804
1805     ref = IDirect3DDevice9_Release(device);
1806     ok(!ref, "The device was not properly freed: refcount %u.\n", ref);
1807 done:
1808     IDirect3D9_Release(d3d9);
1809     DestroyWindow(window);
1810 }
1811
1812 /* Test what happens when IDirect3DDevice9_DrawIndexedPrimitive is called without a valid index buffer set. */
1813 static void test_draw_indexed(void)
1814 {
1815     static const struct {
1816         float position[3];
1817         DWORD color;
1818     } quad[] = {
1819         {{-1.0f, -1.0f, 0.0f}, 0xffff0000},
1820         {{-1.0f,  1.0f, 0.0f}, 0xffff0000},
1821         {{ 1.0f,  1.0f, 0.0f}, 0xffff0000},
1822         {{ 1.0f, -1.0f, 0.0f}, 0xffff0000},
1823     };
1824     WORD indices[] = {0, 1, 2, 3, 0, 2};
1825
1826     static const D3DVERTEXELEMENT9 decl_elements[] = {
1827         {0, 0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1828         {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT,    D3DDECLUSAGE_COLOR, 0},
1829         D3DDECL_END()
1830     };
1831
1832     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1833     IDirect3DVertexBuffer9 *vertex_buffer = NULL;
1834     IDirect3DIndexBuffer9 *index_buffer = NULL;
1835     D3DPRESENT_PARAMETERS present_parameters;
1836     IDirect3DDevice9 *device = NULL;
1837     IDirect3D9 *d3d9;
1838     HRESULT hr;
1839     HWND hwnd;
1840     void *ptr;
1841
1842     hwnd = CreateWindow("d3d9_test_wc", "d3d9_test",
1843             0, 0, 0, 10, 10, 0, 0, 0, 0);
1844     if (!hwnd)
1845     {
1846         skip("Failed to create window\n");
1847         return;
1848     }
1849
1850     d3d9 = pDirect3DCreate9(D3D_SDK_VERSION);
1851     if (!d3d9)
1852     {
1853         skip("Failed to create IDirect3D9 object\n");
1854         goto cleanup;
1855     }
1856
1857     ZeroMemory(&present_parameters, sizeof(present_parameters));
1858     present_parameters.Windowed = TRUE;
1859     present_parameters.hDeviceWindow = hwnd;
1860     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
1861
1862     hr = IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
1863             NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device);
1864     if (FAILED(hr) || !device)
1865     {
1866         skip("Failed to create device\n");
1867         goto cleanup;
1868     }
1869
1870     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1871     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1872     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1873     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1874
1875     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0, D3DPOOL_DEFAULT, &vertex_buffer, NULL);
1876     ok(SUCCEEDED(hr), "CreateVertexBuffer failed (0x%08x)\n", hr);
1877     hr = IDirect3DVertexBuffer9_Lock(vertex_buffer, 0, 0, &ptr, D3DLOCK_DISCARD);
1878     ok(SUCCEEDED(hr), "Lock failed (0x%08x)\n", hr);
1879     memcpy(ptr, quad, sizeof(quad));
1880     hr = IDirect3DVertexBuffer9_Unlock(vertex_buffer);
1881     ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr);
1882     hr = IDirect3DDevice9_SetStreamSource(device, 0, vertex_buffer, 0, sizeof(*quad));
1883     ok(SUCCEEDED(hr), "SetStreamSource failed (0x%08x)\n", hr);
1884
1885     hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &index_buffer, NULL);
1886     ok(SUCCEEDED(hr), "CreateIndexBuffer failed (0x%08x)\n", hr);
1887     hr = IDirect3DIndexBuffer9_Lock(index_buffer, 0, 0, &ptr, D3DLOCK_DISCARD);
1888     ok(SUCCEEDED(hr), "Lock failed (0x%08x)\n", hr);
1889     memcpy(ptr, indices, sizeof(indices));
1890     hr = IDirect3DIndexBuffer9_Unlock(index_buffer);
1891     ok(SUCCEEDED(hr), "Unlock failed (0x%08x)\n", hr);
1892     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1893     ok(SUCCEEDED(hr), "SetRenderState D3DRS_LIGHTING failed (0x%08x)\n", hr);
1894     hr = IDirect3DDevice9_BeginScene(device);
1895     ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1896
1897     /* NULL index buffer. Should fail */
1898     hr = IDirect3DDevice9_SetIndices(device, NULL);
1899     ok(SUCCEEDED(hr), "SetIndices failed (0x%08x)\n", hr);
1900     hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0 /* BaseVertexIndex */, 0 /* MinIndex */,
1901             4 /* NumVerts */, 0 /* StartIndex */, 2 /*PrimCount */);
1902     ok(hr == D3DERR_INVALIDCALL, "DrawIndexedPrimitive returned 0x%08x, expected D3DERR_INVALIDCALL (0x%08x)\n",
1903             hr, D3DERR_INVALIDCALL);
1904
1905     /* Valid index buffer, NULL vertex declaration. Should fail */
1906     hr = IDirect3DDevice9_SetIndices(device, index_buffer);
1907     ok(SUCCEEDED(hr), "SetIndices failed (0x%08x)\n", hr);
1908     hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0 /* BaseVertexIndex */, 0 /* MinIndex */,
1909             4 /* NumVerts */, 0 /* StartIndex */, 2 /*PrimCount */);
1910     ok(hr == D3DERR_INVALIDCALL, "DrawIndexedPrimitive returned 0x%08x, expected D3DERR_INVALIDCALL (0x%08x)\n",
1911             hr, D3DERR_INVALIDCALL);
1912
1913     /* Valid index buffer and vertex declaration. Should succeed */
1914     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1915     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1916     hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0 /* BaseVertexIndex */, 0 /* MinIndex */,
1917             4 /* NumVerts */, 0 /* StartIndex */, 2 /*PrimCount */);
1918     ok(SUCCEEDED(hr), "DrawIndexedPrimitive failed (0x%08x)\n", hr);
1919
1920     hr = IDirect3DDevice9_EndScene(device);
1921     ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1922
1923     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1924     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1925
1926     IDirect3DVertexBuffer9_Release(vertex_buffer);
1927     IDirect3DIndexBuffer9_Release(index_buffer);
1928     IDirect3DVertexDeclaration9_Release(vertex_declaration);
1929
1930 cleanup:
1931     if (device)
1932     {
1933         UINT refcount = IDirect3DDevice9_Release(device);
1934         ok(!refcount, "Device has %u references left.\n", refcount);
1935     }
1936     if (d3d9) IDirect3D9_Release(d3d9);
1937     if (hwnd) DestroyWindow(hwnd);
1938 }
1939
1940 static void test_null_stream(void)
1941 {
1942     IDirect3DVertexBuffer9 *buffer = NULL;
1943     D3DPRESENT_PARAMETERS present_parameters;
1944     IDirect3DDevice9 *device = NULL;
1945     IDirect3D9 *d3d9;
1946     HWND hwnd;
1947     HRESULT hr;
1948     IDirect3DVertexShader9 *shader = NULL;
1949     IDirect3DVertexDeclaration9 *decl = NULL;
1950     DWORD shader_code[] = {
1951         0xfffe0101,                             /* vs_1_1           */
1952         0x0000001f, 0x80000000, 0x900f0000,     /* dcl_position v0  */
1953         0x00000001, 0xc00f0000, 0x90e40000,     /* mov oPos, v0     */
1954         0x0000ffff                              /* end              */
1955     };
1956     static const D3DVERTEXELEMENT9 decl_elements[] = {
1957         {0, 0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1958         {1, 0,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT,    D3DDECLUSAGE_COLOR, 0},
1959         D3DDECL_END()
1960     };
1961
1962     d3d9 = pDirect3DCreate9( D3D_SDK_VERSION );
1963     ok(d3d9 != NULL, "Failed to create IDirect3D9 object\n");
1964     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1965     ok(hwnd != NULL, "Failed to create window\n");
1966     if (!d3d9 || !hwnd) goto cleanup;
1967
1968     ZeroMemory(&present_parameters, sizeof(present_parameters));
1969     present_parameters.Windowed = TRUE;
1970     present_parameters.hDeviceWindow = hwnd;
1971     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
1972
1973     hr = IDirect3D9_CreateDevice( d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1974                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device );
1975     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D9_CreateDevice failed with %08x\n", hr);
1976     if(!device)
1977     {
1978         skip("Failed to create a d3d device\n");
1979         goto cleanup;
1980     }
1981
1982     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
1983     if(FAILED(hr)) {
1984         skip("No vertex shader support\n");
1985         goto cleanup;
1986     }
1987     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
1988     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed (0x%08x)\n", hr);
1989     if (FAILED(hr)) {
1990         skip("Vertex declaration handling not possible.\n");
1991         goto cleanup;
1992     }
1993     hr = IDirect3DDevice9_CreateVertexBuffer(device, 12 * sizeof(float), 0, 0, D3DPOOL_MANAGED, &buffer, NULL);
1994     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexBuffer failed (0x%08x)\n", hr);
1995     if (FAILED(hr)) {
1996         skip("Vertex buffer handling not possible.\n");
1997         goto cleanup;
1998     }
1999
2000     hr = IDirect3DDevice9_SetStreamSource(device, 0, buffer, 0, sizeof(float) * 3);
2001     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetStreamSource failed (0x%08x)\n", hr);
2002     hr = IDirect3DDevice9_SetStreamSource(device, 1, NULL, 0, 0);
2003     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetStreamSource failed (0x%08x)\n", hr);
2004     hr = IDirect3DDevice9_SetVertexShader(device, shader);
2005     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed (0x%08x)\n", hr);
2006     hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
2007     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexDeclaration failed (0x%08x)\n", hr);
2008
2009     hr = IDirect3DDevice9_BeginScene(device);
2010     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (0x%08x)\n", hr);
2011     if(SUCCEEDED(hr)) {
2012         hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_POINTLIST, 0, 1);
2013         ok(SUCCEEDED(hr), "IDirect3DDevice9_DrawPrimitive failed (0x%08x)\n", hr);
2014
2015         hr = IDirect3DDevice9_EndScene(device);
2016         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed (0x%08x)\n", hr);
2017     }
2018
2019     IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2020     IDirect3DDevice9_SetVertexShader(device, NULL);
2021     IDirect3DDevice9_SetVertexDeclaration(device, NULL);
2022
2023 cleanup:
2024     if (buffer) IDirect3DVertexBuffer9_Release(buffer);
2025     if(decl) IDirect3DVertexDeclaration9_Release(decl);
2026     if(shader) IDirect3DVertexShader9_Release(shader);
2027     if (device)
2028     {
2029         UINT refcount = IDirect3DDevice9_Release(device);
2030         ok(!refcount, "Device has %u references left.\n", refcount);
2031     }
2032     if(d3d9) IDirect3D9_Release(d3d9);
2033 }
2034
2035 static void test_lights(void)
2036 {
2037     D3DPRESENT_PARAMETERS present_parameters;
2038     IDirect3DDevice9 *device = NULL;
2039     IDirect3D9 *d3d9;
2040     HWND hwnd;
2041     HRESULT hr;
2042     unsigned int i;
2043     BOOL enabled;
2044     D3DCAPS9 caps;
2045
2046     d3d9 = pDirect3DCreate9( D3D_SDK_VERSION );
2047     ok(d3d9 != NULL, "Failed to create IDirect3D9 object\n");
2048     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
2049     ok(hwnd != NULL, "Failed to create window\n");
2050     if (!d3d9 || !hwnd) goto cleanup;
2051
2052     ZeroMemory(&present_parameters, sizeof(present_parameters));
2053     present_parameters.Windowed = TRUE;
2054     present_parameters.hDeviceWindow = hwnd;
2055     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
2056
2057     hr = IDirect3D9_CreateDevice( d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
2058                                   D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device );
2059     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
2060        "IDirect3D9_CreateDevice failed with %08x\n", hr);
2061     if(!device)
2062     {
2063         skip("Failed to create a d3d device\n");
2064         goto cleanup;
2065     }
2066
2067     memset(&caps, 0, sizeof(caps));
2068     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
2069     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed with %08x\n", hr);
2070
2071     for(i = 1; i <= caps.MaxActiveLights; i++) {
2072         hr = IDirect3DDevice9_LightEnable(device, i, TRUE);
2073         ok(hr == D3D_OK, "Enabling light %u failed with %08x\n", i, hr);
2074         hr = IDirect3DDevice9_GetLightEnable(device, i, &enabled);
2075         ok(hr == D3D_OK, "GetLightEnable on light %u failed with %08x\n", i, hr);
2076         ok(enabled, "Light %d is %s\n", i, enabled ? "enabled" : "disabled");
2077     }
2078
2079     /* TODO: Test the rendering results in this situation */
2080     hr = IDirect3DDevice9_LightEnable(device, i + 1, TRUE);
2081     ok(hr == D3D_OK, "Enabling one light more than supported returned %08x\n", hr);
2082     hr = IDirect3DDevice9_GetLightEnable(device, i + 1, &enabled);
2083     ok(hr == D3D_OK, "GetLightEnable on light %u failed with %08x\n", i + 1, hr);
2084     ok(enabled, "Light %d is %s\n", i + 1, enabled ? "enabled" : "disabled");
2085     hr = IDirect3DDevice9_LightEnable(device, i + 1, FALSE);
2086     ok(hr == D3D_OK, "Disabling the additional returned %08x\n", hr);
2087
2088     for(i = 1; i <= caps.MaxActiveLights; i++) {
2089         hr = IDirect3DDevice9_LightEnable(device, i, FALSE);
2090         ok(hr == D3D_OK, "Disabling light %u failed with %08x\n", i, hr);
2091     }
2092
2093 cleanup:
2094     if (device)
2095     {
2096         UINT refcount = IDirect3DDevice9_Release(device);
2097         ok(!refcount, "Device has %u references left.\n", refcount);
2098     }
2099     if(d3d9) IDirect3D9_Release(d3d9);
2100 }
2101
2102 static void test_set_stream_source(void)
2103 {
2104     D3DPRESENT_PARAMETERS present_parameters;
2105     IDirect3DDevice9 *device = NULL;
2106     IDirect3D9 *d3d9;
2107     HWND hwnd;
2108     HRESULT hr;
2109     IDirect3DVertexBuffer9 *pVertexBuffer = NULL;
2110
2111     d3d9 = pDirect3DCreate9( D3D_SDK_VERSION );
2112     ok(d3d9 != NULL, "Failed to create IDirect3D9 object\n");
2113     hwnd = CreateWindow( "d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
2114     ok(hwnd != NULL, "Failed to create window\n");
2115     if (!d3d9 || !hwnd) goto cleanup;
2116
2117     ZeroMemory(&present_parameters, sizeof(present_parameters));
2118     present_parameters.Windowed = TRUE;
2119     present_parameters.hDeviceWindow = hwnd;
2120     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
2121
2122     hr = IDirect3D9_CreateDevice( d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
2123                                   D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device );
2124     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
2125        "IDirect3D9_CreateDevice failed with %08x\n", hr);
2126     if(!device)
2127     {
2128         hr = IDirect3D9_CreateDevice( d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, hwnd,
2129                                       D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device );
2130         ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
2131            "IDirect3D9_CreateDevice failed with %08x\n", hr);
2132         if(!device)
2133         {
2134             skip("Failed to create a d3d device\n");
2135             goto cleanup;
2136         }
2137     }
2138
2139     hr = IDirect3DDevice9_CreateVertexBuffer( device, 512, 0, 0, D3DPOOL_DEFAULT, &pVertexBuffer, NULL );
2140     ok(hr == D3D_OK, "Failed to create a vertex buffer, hr = %08x\n", hr);
2141     if (SUCCEEDED(hr)) {
2142         /* Some cards(Geforce 7400 at least) accept non-aligned offsets, others(radeon 9000 verified) reject it,
2143          * so accept both results. Wine currently rejects this to be able to optimize the vbo conversion, but writes
2144          * a WARN
2145          */
2146         hr = IDirect3DDevice9_SetStreamSource(device, 0, pVertexBuffer, 0, 32);
2147         ok(hr == D3D_OK, "Failed to set the stream source, offset 0, hr = %08x\n", hr);
2148         hr = IDirect3DDevice9_SetStreamSource(device, 0, pVertexBuffer, 1, 32);
2149         ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "Unexpected result when setting the stream source, offset 1, hr = %08x\n", hr);
2150         hr = IDirect3DDevice9_SetStreamSource(device, 0, pVertexBuffer, 2, 32);
2151         ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "Unexpected result when setting the stream source, offset 2, hr = %08x\n", hr);
2152         hr = IDirect3DDevice9_SetStreamSource(device, 0, pVertexBuffer, 3, 32);
2153         ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "Unexpected result when setting the stream source, offset 3, hr = %08x\n", hr);
2154         hr = IDirect3DDevice9_SetStreamSource(device, 0, pVertexBuffer, 4, 32);
2155         ok(hr == D3D_OK, "Failed to set the stream source, offset 4, hr = %08x\n", hr);
2156     }
2157     /* Try to set the NULL buffer with an offset and stride 0 */
2158     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2159     ok(hr == D3D_OK, "Failed to set the stream source, offset 0, hr = %08x\n", hr);
2160     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 1, 0);
2161     ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "Unexpected result when setting the stream source, offset 1, hr = %08x\n", hr);
2162     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 2, 0);
2163     ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "Unexpected result when setting the stream source, offset 2, hr = %08x\n", hr);
2164     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 3, 0);
2165     ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "Unexpected result when setting the stream source, offset 3, hr = %08x\n", hr);
2166     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 4, 0);
2167     ok(hr == D3D_OK, "Failed to set the stream source, offset 4, hr = %08x\n", hr);
2168
2169     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2170     ok(hr == D3D_OK, "Failed to set the stream source, offset 4, hr = %08x\n", hr);
2171
2172 cleanup:
2173     if (pVertexBuffer) IDirect3DVertexBuffer9_Release(pVertexBuffer);
2174     if (device)
2175     {
2176         UINT refcount = IDirect3DDevice9_Release(device);
2177         ok(!refcount, "Device has %u references left.\n", refcount);
2178     }
2179     if(d3d9) IDirect3D9_Release(d3d9);
2180 }
2181
2182 struct formats {
2183     D3DFORMAT DisplayFormat;
2184     D3DFORMAT BackBufferFormat;
2185     BOOL shouldPass;
2186 };
2187
2188 static const struct formats r5g6b5_format_list[] =
2189 {
2190     { D3DFMT_R5G6B5, D3DFMT_R5G6B5, TRUE },
2191     { D3DFMT_R5G6B5, D3DFMT_X1R5G5B5, FALSE },
2192     { D3DFMT_R5G6B5, D3DFMT_A1R5G5B5, FALSE },
2193     { D3DFMT_R5G6B5, D3DFMT_X8R8G8B8, FALSE },
2194     { D3DFMT_R5G6B5, D3DFMT_A8R8G8B8, FALSE },
2195     { 0, 0, 0}
2196 };
2197
2198 static const struct formats x1r5g5b5_format_list[] =
2199 {
2200     { D3DFMT_X1R5G5B5, D3DFMT_R5G6B5, FALSE },
2201     { D3DFMT_X1R5G5B5, D3DFMT_X1R5G5B5, TRUE },
2202     { D3DFMT_X1R5G5B5, D3DFMT_A1R5G5B5, TRUE },
2203     { D3DFMT_X1R5G5B5, D3DFMT_X8R8G8B8, FALSE },
2204     { D3DFMT_X1R5G5B5, D3DFMT_A8R8G8B8, FALSE },
2205
2206     /* A1R5G5B5 should not be usable as a display format, it is backbuffer-only */
2207     { D3DFMT_A1R5G5B5, D3DFMT_R5G6B5, FALSE },
2208     { D3DFMT_A1R5G5B5, D3DFMT_X1R5G5B5, FALSE },
2209     { D3DFMT_A1R5G5B5, D3DFMT_A1R5G5B5, FALSE },
2210     { D3DFMT_A1R5G5B5, D3DFMT_X8R8G8B8, FALSE },
2211     { D3DFMT_A1R5G5B5, D3DFMT_A8R8G8B8, FALSE },
2212     { 0, 0, 0}
2213 };
2214
2215 static const struct formats x8r8g8b8_format_list[] =
2216 {
2217     { D3DFMT_X8R8G8B8, D3DFMT_R5G6B5, FALSE },
2218     { D3DFMT_X8R8G8B8, D3DFMT_X1R5G5B5, FALSE },
2219     { D3DFMT_X8R8G8B8, D3DFMT_A1R5G5B5, FALSE },
2220     { D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, TRUE },
2221     { D3DFMT_X8R8G8B8, D3DFMT_A8R8G8B8, TRUE },
2222
2223     /* A1R8G8B8 should not be usable as a display format, it is backbuffer-only */
2224     { D3DFMT_A8R8G8B8, D3DFMT_R5G6B5, FALSE },
2225     { D3DFMT_A8R8G8B8, D3DFMT_X1R5G5B5, FALSE },
2226     { D3DFMT_A8R8G8B8, D3DFMT_A1R5G5B5, FALSE },
2227     { D3DFMT_A8R8G8B8, D3DFMT_X8R8G8B8, FALSE },
2228     { D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, FALSE },
2229     { 0, 0, 0}
2230 };
2231
2232 static void test_display_formats(void)
2233 {
2234     /* Direct3D9 offers 4 display formats R5G6B5, X1R5G5B5, X8R8G8B8 and A2R10G10B10.
2235      * Next to these there are 6 different backbuffer formats. Only a fixed number of
2236      * combinations are possible in FULLSCREEN mode. In windowed mode more combinations are
2237      * allowed due to depth conversion and this is likely driver dependent.
2238      * This test checks which combinations are possible in fullscreen mode and this should not be driver dependent.
2239      * TODO: handle A2R10G10B10 but what hardware supports it? Parhelia? It is very rare. */
2240
2241     UINT Adapter = D3DADAPTER_DEFAULT;
2242     D3DDEVTYPE DeviceType = D3DDEVTYPE_HAL;
2243     int i, nmodes;
2244     HRESULT hr;
2245
2246     IDirect3D9 *d3d9 = pDirect3DCreate9( D3D_SDK_VERSION );
2247     ok(d3d9 != NULL, "Failed to create IDirect3D9 object\n");
2248     if(!d3d9) return;
2249
2250     nmodes = IDirect3D9_GetAdapterModeCount(d3d9, D3DADAPTER_DEFAULT, D3DFMT_R5G6B5);
2251     if(!nmodes) {
2252         skip("Display format R5G6B5 not supported, skipping\n");
2253     } else {
2254         trace("Testing display format R5G6B5\n");
2255         for(i=0; r5g6b5_format_list[i].DisplayFormat != 0; i++)
2256         {
2257             hr = IDirect3D9_CheckDeviceType(d3d9, Adapter, DeviceType, r5g6b5_format_list[i].DisplayFormat, r5g6b5_format_list[i].BackBufferFormat, FALSE);
2258
2259             if(r5g6b5_format_list[i].shouldPass)
2260                 ok(hr == D3D_OK ||
2261                    broken(hr == D3DERR_NOTAVAILABLE),
2262                    "format %d %d didn't pass with hr=%#08x\n", r5g6b5_format_list[i].DisplayFormat, r5g6b5_format_list[i].BackBufferFormat, hr);
2263             else
2264                 ok(hr != D3D_OK, "format %d %d didn't pass while it was expected to\n", r5g6b5_format_list[i].DisplayFormat, r5g6b5_format_list[i].BackBufferFormat);
2265         }
2266     }
2267
2268     nmodes = IDirect3D9_GetAdapterModeCount(d3d9, D3DADAPTER_DEFAULT, D3DFMT_X1R5G5B5);
2269     if(!nmodes) {
2270         skip("Display format X1R5G5B5 not supported, skipping\n");
2271     } else {
2272         trace("Testing display format X1R5G5B5\n");
2273         for(i=0; x1r5g5b5_format_list[i].DisplayFormat != 0; i++)
2274         {
2275             hr = IDirect3D9_CheckDeviceType(d3d9, Adapter, DeviceType, x1r5g5b5_format_list[i].DisplayFormat, x1r5g5b5_format_list[i].BackBufferFormat, FALSE);
2276
2277             if(x1r5g5b5_format_list[i].shouldPass)
2278                 ok(hr == D3D_OK, "format %d %d didn't pass with hr=%#08x\n", x1r5g5b5_format_list[i].DisplayFormat, x1r5g5b5_format_list[i].BackBufferFormat, hr);
2279             else
2280                 ok(hr != D3D_OK, "format %d %d didn't pass while it was expected to\n", x1r5g5b5_format_list[i].DisplayFormat, x1r5g5b5_format_list[i].BackBufferFormat);
2281         }
2282     }
2283
2284     nmodes = IDirect3D9_GetAdapterModeCount(d3d9, D3DADAPTER_DEFAULT, D3DFMT_X8R8G8B8);
2285     if(!nmodes) {
2286         skip("Display format X8R8G8B8 not supported, skipping\n");
2287     } else {
2288         trace("Testing display format X8R8G8B8\n");
2289         for(i=0; x8r8g8b8_format_list[i].DisplayFormat != 0; i++)
2290         {
2291             hr = IDirect3D9_CheckDeviceType(d3d9, Adapter, DeviceType, x8r8g8b8_format_list[i].DisplayFormat, x8r8g8b8_format_list[i].BackBufferFormat, FALSE);
2292
2293             if(x8r8g8b8_format_list[i].shouldPass)
2294                 ok(hr == D3D_OK ||
2295                    broken(hr == D3DERR_NOTAVAILABLE),
2296                    "format %d %d didn't pass with hr=%#08x\n", x8r8g8b8_format_list[i].DisplayFormat, x8r8g8b8_format_list[i].BackBufferFormat, hr);
2297             else
2298                 ok(hr != D3D_OK, "format %d %d didn't pass while it was expected to\n", x8r8g8b8_format_list[i].DisplayFormat, x8r8g8b8_format_list[i].BackBufferFormat);
2299         }
2300     }
2301
2302     if(d3d9) IDirect3D9_Release(d3d9);
2303 }
2304
2305 static void test_scissor_size(void)
2306 {
2307     IDirect3D9 *d3d9_ptr = 0;
2308     unsigned int i;
2309     static struct {
2310         int winx; int winy; int backx; int backy; BOOL window;
2311     } scts[] = { /* scissor tests */
2312         {800, 600, 640, 480, TRUE},
2313         {800, 600, 640, 480, FALSE},
2314         {640, 480, 800, 600, TRUE},
2315         {640, 480, 800, 600, FALSE},
2316     };
2317
2318     d3d9_ptr = pDirect3DCreate9(D3D_SDK_VERSION);
2319     ok(d3d9_ptr != NULL, "Failed to create IDirect3D9 object\n");
2320     if (!d3d9_ptr){
2321         skip("Failed to create IDirect3D9 object\n");
2322         return;
2323     }
2324
2325     for(i=0; i<sizeof(scts)/sizeof(scts[0]); i++) {
2326         IDirect3DDevice9 *device_ptr = 0;
2327         D3DPRESENT_PARAMETERS present_parameters;
2328         HRESULT hr;
2329         HWND hwnd = 0;
2330         RECT scissorrect;
2331
2332         hwnd = CreateWindow("d3d9_test_wc", "d3d9_test",
2333                         WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, scts[i].winx, scts[i].winy, 0, 0, 0, 0);
2334
2335         if (!scts[i].window)
2336         {
2337             scts[i].backx = screen_width;
2338             scts[i].backy = screen_height;
2339         }
2340
2341         ZeroMemory(&present_parameters, sizeof(present_parameters));
2342         present_parameters.Windowed = scts[i].window;
2343         present_parameters.hDeviceWindow = hwnd;
2344         present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
2345         present_parameters.BackBufferWidth = scts[i].backx;
2346         present_parameters.BackBufferHeight = scts[i].backy;
2347         present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
2348         present_parameters.EnableAutoDepthStencil = TRUE;
2349         present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
2350
2351         hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
2352         if(FAILED(hr)) {
2353             present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
2354             hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
2355             if(FAILED(hr)) {
2356                 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
2357             }
2358         }
2359         ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D_CreateDevice returned: %08x\n", hr);
2360
2361         if (!device_ptr)
2362         {
2363             DestroyWindow(hwnd);
2364             skip("Creating the device failed\n");
2365             goto err_out;
2366         }
2367
2368         /* Check for the default scissor rect size */
2369         hr = IDirect3DDevice9_GetScissorRect(device_ptr, &scissorrect);
2370         ok(hr == D3D_OK, "IDirect3DDevice9_GetScissorRect failed with: %08x\n", hr);
2371         ok(scissorrect.right == scts[i].backx && scissorrect.bottom == scts[i].backy && scissorrect.top == 0 && scissorrect.left == 0, "Scissorrect missmatch (%d, %d) should be (%d, %d)\n", scissorrect.right, scissorrect.bottom, scts[i].backx, scts[i].backy);
2372
2373         /* check the scissorrect values after a reset */
2374         present_parameters.BackBufferWidth = screen_width;
2375         present_parameters.BackBufferHeight = screen_height;
2376         hr = IDirect3DDevice9_Reset(device_ptr, &present_parameters);
2377         ok(hr == D3D_OK, "IDirect3DDevice9_Reset failed with %08x\n", hr);
2378         hr = IDirect3DDevice9_TestCooperativeLevel(device_ptr);
2379         ok(hr == D3D_OK, "IDirect3DDevice9_TestCooperativeLevel after a successful reset returned %#x\n", hr);
2380
2381         hr = IDirect3DDevice9_GetScissorRect(device_ptr, &scissorrect);
2382         ok(hr == D3D_OK, "IDirect3DDevice9_GetScissorRect failed with: %08x\n", hr);
2383         ok(scissorrect.right == screen_width && scissorrect.bottom == screen_height && scissorrect.top == 0 && scissorrect.left == 0, "Scissorrect missmatch (%d, %d) should be (%d, %d)\n", scissorrect.right, scissorrect.bottom, screen_width, screen_height);
2384
2385         if(device_ptr) {
2386             ULONG ref;
2387
2388             ref = IDirect3DDevice9_Release(device_ptr);
2389             DestroyWindow(hwnd);
2390             ok(ref == 0, "The device was not properly freed: refcount %u\n", ref);
2391         }
2392     }
2393
2394 err_out:
2395     if(d3d9_ptr) IDirect3D9_Release(d3d9_ptr);
2396     return;
2397 }
2398
2399 static void test_multi_device(void)
2400 {
2401     IDirect3DDevice9 *device1 = NULL, *device2 = NULL;
2402     D3DPRESENT_PARAMETERS present_parameters;
2403     HWND hwnd1 = NULL, hwnd2 = NULL;
2404     IDirect3D9 *d3d9;
2405     ULONG refcount;
2406     HRESULT hr;
2407
2408     d3d9 = pDirect3DCreate9(D3D_SDK_VERSION);
2409     ok(d3d9 != NULL, "Failed to create a d3d9 object.\n");
2410     if (!d3d9) goto fail;
2411
2412     hwnd1 = CreateWindow("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL);
2413     ok(hwnd1 != NULL, "Failed to create a window.\n");
2414     if (!hwnd1) goto fail;
2415
2416     memset(&present_parameters, 0, sizeof(present_parameters));
2417     present_parameters.Windowed = TRUE;
2418     present_parameters.hDeviceWindow = hwnd1;
2419     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
2420
2421     hr = IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd1,
2422             D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device1);
2423     IDirect3D9_Release(d3d9);
2424     d3d9 = NULL;
2425     if (FAILED(hr)) {
2426         skip("Failed to create a device\n");
2427         goto fail;
2428     }
2429
2430     d3d9 = pDirect3DCreate9(D3D_SDK_VERSION);
2431     ok(d3d9 != NULL, "Failed to create a d3d9 object.\n");
2432     if (!d3d9) goto fail;
2433
2434     hwnd2 = CreateWindow("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL);
2435     ok(hwnd2 != NULL, "Failed to create a window.\n");
2436     if (!hwnd2) goto fail;
2437
2438     memset(&present_parameters, 0, sizeof(present_parameters));
2439     present_parameters.Windowed = TRUE;
2440     present_parameters.hDeviceWindow = hwnd2;
2441     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
2442
2443     hr = IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd2,
2444             D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device2);
2445     ok(SUCCEEDED(hr), "Failed to create a device, hr %#x\n", hr);
2446     IDirect3D9_Release(d3d9);
2447     d3d9 = NULL;
2448     if (FAILED(hr)) goto fail;
2449
2450 fail:
2451     if (d3d9) IDirect3D9_Release(d3d9);
2452     if (device1)
2453     {
2454         refcount = IDirect3DDevice9_Release(device1);
2455         ok(!refcount, "Device has %u references left.\n", refcount);
2456     }
2457     if (device2)
2458     {
2459         refcount = IDirect3DDevice9_Release(device2);
2460         ok(!refcount, "Device has %u references left.\n", refcount);
2461     }
2462     if (hwnd1) DestroyWindow(hwnd1);
2463     if (hwnd2) DestroyWindow(hwnd2);
2464 }
2465
2466 static HWND filter_messages;
2467
2468 enum message_window
2469 {
2470     DEVICE_WINDOW,
2471     FOCUS_WINDOW,
2472 };
2473
2474 struct message
2475 {
2476     UINT message;
2477     enum message_window window;
2478 };
2479
2480 static const struct message *expect_messages;
2481 static HWND device_window, focus_window;
2482
2483 struct wndproc_thread_param
2484 {
2485     HWND dummy_window;
2486     HANDLE window_created;
2487     HANDLE test_finished;
2488     BOOL running_in_foreground;
2489 };
2490
2491 static LRESULT CALLBACK test_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
2492 {
2493     if (filter_messages && filter_messages == hwnd)
2494     {
2495         if (message != WM_DISPLAYCHANGE && message != WM_IME_NOTIFY)
2496             todo_wine ok( 0, "Received unexpected message %#x for window %p.\n", message, hwnd);
2497     }
2498
2499     if (expect_messages)
2500     {
2501         HWND w;
2502
2503         switch (expect_messages->window)
2504         {
2505             case DEVICE_WINDOW:
2506                 w = device_window;
2507                 break;
2508
2509             case FOCUS_WINDOW:
2510                 w = focus_window;
2511                 break;
2512
2513             default:
2514                 w = NULL;
2515                 break;
2516         };
2517
2518         if (hwnd == w && expect_messages->message == message) ++expect_messages;
2519     }
2520
2521     return DefWindowProcA(hwnd, message, wparam, lparam);
2522 }
2523
2524 static DWORD WINAPI wndproc_thread(void *param)
2525 {
2526     struct wndproc_thread_param *p = param;
2527     DWORD res;
2528     BOOL ret;
2529
2530     p->dummy_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test",
2531             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
2532     p->running_in_foreground = SetForegroundWindow(p->dummy_window);
2533
2534     ret = SetEvent(p->window_created);
2535     ok(ret, "SetEvent failed, last error %#x.\n", GetLastError());
2536
2537     for (;;)
2538     {
2539         MSG msg;
2540
2541         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
2542         res = WaitForSingleObject(p->test_finished, 100);
2543         if (res == WAIT_OBJECT_0) break;
2544         if (res != WAIT_TIMEOUT)
2545         {
2546             ok(0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
2547             break;
2548         }
2549     }
2550
2551     DestroyWindow(p->dummy_window);
2552
2553     return 0;
2554 }
2555
2556 static void test_wndproc(void)
2557 {
2558     struct wndproc_thread_param thread_params;
2559     IDirect3DDevice9 *device;
2560     WNDCLASSA wc = {0};
2561     IDirect3D9 *d3d9;
2562     HANDLE thread;
2563     LONG_PTR proc;
2564     ULONG ref;
2565     DWORD res, tid;
2566     HWND tmp;
2567
2568     static const struct message messages[] =
2569     {
2570         {WM_WINDOWPOSCHANGING,  FOCUS_WINDOW},
2571         {WM_ACTIVATE,           FOCUS_WINDOW},
2572         {WM_SETFOCUS,           FOCUS_WINDOW},
2573         {0,                     0},
2574     };
2575
2576     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
2577     {
2578         skip("Failed to create IDirect3D9 object, skipping tests.\n");
2579         return;
2580     }
2581
2582     wc.lpfnWndProc = test_proc;
2583     wc.lpszClassName = "d3d9_test_wndproc_wc";
2584     ok(RegisterClassA(&wc), "Failed to register window class.\n");
2585
2586     thread_params.window_created = CreateEvent(NULL, FALSE, FALSE, NULL);
2587     ok(!!thread_params.window_created, "CreateEvent failed, last error %#x.\n", GetLastError());
2588     thread_params.test_finished = CreateEvent(NULL, FALSE, FALSE, NULL);
2589     ok(!!thread_params.test_finished, "CreateEvent failed, last error %#x.\n", GetLastError());
2590
2591     focus_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test",
2592             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
2593     device_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test",
2594             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
2595     thread = CreateThread(NULL, 0, wndproc_thread, &thread_params, 0, &tid);
2596     ok(!!thread, "Failed to create thread, last error %#x.\n", GetLastError());
2597
2598     res = WaitForSingleObject(thread_params.window_created, INFINITE);
2599     ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
2600
2601     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2602     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2603             (LONG_PTR)test_proc, proc);
2604     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2605     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2606             (LONG_PTR)test_proc, proc);
2607
2608     trace("device_window %p, focus_window %p, dummy_window %p.\n",
2609             device_window, focus_window, thread_params.dummy_window);
2610
2611     tmp = GetFocus();
2612     ok(tmp == device_window, "Expected focus %p, got %p.\n", device_window, tmp);
2613     if (thread_params.running_in_foreground)
2614     {
2615         tmp = GetForegroundWindow();
2616         ok(tmp == thread_params.dummy_window, "Expected foreground window %p, got %p.\n",
2617                 thread_params.dummy_window, tmp);
2618     }
2619     else
2620         skip("Not running in foreground, skip foreground window test\n");
2621
2622     flush_events();
2623
2624     expect_messages = messages;
2625
2626     device = create_device(d3d9, device_window, focus_window, FALSE);
2627     if (!device)
2628     {
2629         skip("Failed to create a D3D device, skipping tests.\n");
2630         goto done;
2631     }
2632
2633     ok(!expect_messages->message, "Expected message %#x for window %#x, but didn't receive it.\n",
2634             expect_messages->message, expect_messages->window);
2635     expect_messages = NULL;
2636
2637     if (0) /* Disabled until we can make this work in a reliable way on Wine. */
2638     {
2639         tmp = GetFocus();
2640         ok(tmp == focus_window, "Expected focus %p, got %p.\n", focus_window, tmp);
2641         tmp = GetForegroundWindow();
2642         ok(tmp == focus_window, "Expected foreground window %p, got %p.\n", focus_window, tmp);
2643     }
2644     SetForegroundWindow(focus_window);
2645     flush_events();
2646
2647     filter_messages = focus_window;
2648
2649     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2650     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2651             (LONG_PTR)test_proc, proc);
2652
2653     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2654     ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
2655             (LONG_PTR)test_proc, proc);
2656
2657     ref = IDirect3DDevice9_Release(device);
2658     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
2659
2660     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2661     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2662             (LONG_PTR)test_proc, proc);
2663
2664     device = create_device(d3d9, focus_window, focus_window, FALSE);
2665     if (!device)
2666     {
2667         skip("Failed to create a D3D device, skipping tests.\n");
2668         goto done;
2669     }
2670
2671     ref = IDirect3DDevice9_Release(device);
2672     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
2673
2674     device = create_device(d3d9, device_window, focus_window, FALSE);
2675     if (!device)
2676     {
2677         skip("Failed to create a D3D device, skipping tests.\n");
2678         goto done;
2679     }
2680
2681     proc = SetWindowLongPtrA(focus_window, GWLP_WNDPROC, (LONG_PTR)DefWindowProcA);
2682     ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
2683             (LONG_PTR)test_proc, proc);
2684
2685     ref = IDirect3DDevice9_Release(device);
2686     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
2687
2688     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2689     ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n",
2690             (LONG_PTR)DefWindowProcA, proc);
2691
2692 done:
2693     filter_messages = NULL;
2694     IDirect3D9_Release(d3d9);
2695
2696     SetEvent(thread_params.test_finished);
2697     WaitForSingleObject(thread, INFINITE);
2698     CloseHandle(thread_params.test_finished);
2699     CloseHandle(thread_params.window_created);
2700     CloseHandle(thread);
2701
2702     DestroyWindow(device_window);
2703     DestroyWindow(focus_window);
2704     UnregisterClassA("d3d9_test_wndproc_wc", GetModuleHandleA(NULL));
2705 }
2706
2707 static void test_wndproc_windowed(void)
2708 {
2709     struct wndproc_thread_param thread_params;
2710     IDirect3DDevice9 *device;
2711     WNDCLASSA wc = {0};
2712     IDirect3D9 *d3d9;
2713     HANDLE thread;
2714     LONG_PTR proc;
2715     HRESULT hr;
2716     ULONG ref;
2717     DWORD res, tid;
2718     HWND tmp;
2719
2720     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
2721     {
2722         skip("Failed to create IDirect3D9 object, skipping tests.\n");
2723         return;
2724     }
2725
2726     wc.lpfnWndProc = test_proc;
2727     wc.lpszClassName = "d3d9_test_wndproc_wc";
2728     ok(RegisterClassA(&wc), "Failed to register window class.\n");
2729
2730     thread_params.window_created = CreateEvent(NULL, FALSE, FALSE, NULL);
2731     ok(!!thread_params.window_created, "CreateEvent failed, last error %#x.\n", GetLastError());
2732     thread_params.test_finished = CreateEvent(NULL, FALSE, FALSE, NULL);
2733     ok(!!thread_params.test_finished, "CreateEvent failed, last error %#x.\n", GetLastError());
2734
2735     focus_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test",
2736             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
2737     device_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test",
2738             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
2739     thread = CreateThread(NULL, 0, wndproc_thread, &thread_params, 0, &tid);
2740     ok(!!thread, "Failed to create thread, last error %#x.\n", GetLastError());
2741
2742     res = WaitForSingleObject(thread_params.window_created, INFINITE);
2743     ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
2744
2745     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2746     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2747             (LONG_PTR)test_proc, proc);
2748     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2749     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2750             (LONG_PTR)test_proc, proc);
2751
2752     trace("device_window %p, focus_window %p, dummy_window %p.\n",
2753             device_window, focus_window, thread_params.dummy_window);
2754
2755     tmp = GetFocus();
2756     ok(tmp == device_window, "Expected focus %p, got %p.\n", device_window, tmp);
2757     if (thread_params.running_in_foreground)
2758     {
2759         tmp = GetForegroundWindow();
2760         ok(tmp == thread_params.dummy_window, "Expected foreground window %p, got %p.\n",
2761                 thread_params.dummy_window, tmp);
2762     }
2763     else
2764         skip("Not running in foreground, skip foreground window test\n");
2765
2766     filter_messages = focus_window;
2767
2768     device = create_device(d3d9, device_window, focus_window, TRUE);
2769     if (!device)
2770     {
2771         skip("Failed to create a D3D device, skipping tests.\n");
2772         goto done;
2773     }
2774
2775     tmp = GetFocus();
2776     ok(tmp == device_window, "Expected focus %p, got %p.\n", device_window, tmp);
2777     tmp = GetForegroundWindow();
2778     ok(tmp == thread_params.dummy_window, "Expected foreground window %p, got %p.\n",
2779             thread_params.dummy_window, tmp);
2780
2781     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2782     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2783             (LONG_PTR)test_proc, proc);
2784
2785     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2786     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2787             (LONG_PTR)test_proc, proc);
2788
2789     filter_messages = NULL;
2790
2791     hr = reset_device(device, device_window, FALSE);
2792     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
2793
2794     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2795     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2796             (LONG_PTR)test_proc, proc);
2797
2798     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2799     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2800             (LONG_PTR)test_proc, proc);
2801
2802     hr = reset_device(device, device_window, TRUE);
2803     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
2804
2805     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2806     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2807             (LONG_PTR)test_proc, proc);
2808
2809     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2810     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2811             (LONG_PTR)test_proc, proc);
2812
2813     filter_messages = focus_window;
2814
2815     ref = IDirect3DDevice9_Release(device);
2816     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
2817
2818     filter_messages = device_window;
2819
2820     device = create_device(d3d9, focus_window, focus_window, TRUE);
2821     if (!device)
2822     {
2823         skip("Failed to create a D3D device, skipping tests.\n");
2824         goto done;
2825     }
2826
2827     filter_messages = NULL;
2828
2829     hr = reset_device(device, focus_window, FALSE);
2830     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
2831
2832     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2833     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2834             (LONG_PTR)test_proc, proc);
2835
2836     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2837     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2838             (LONG_PTR)test_proc, proc);
2839
2840     hr = reset_device(device, focus_window, TRUE);
2841     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
2842
2843     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2844     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2845             (LONG_PTR)test_proc, proc);
2846
2847     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2848     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2849             (LONG_PTR)test_proc, proc);
2850
2851     filter_messages = device_window;
2852
2853     ref = IDirect3DDevice9_Release(device);
2854     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
2855
2856     device = create_device(d3d9, device_window, focus_window, TRUE);
2857     if (!device)
2858     {
2859         skip("Failed to create a D3D device, skipping tests.\n");
2860         goto done;
2861     }
2862
2863     filter_messages = NULL;
2864
2865     hr = reset_device(device, device_window, FALSE);
2866     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
2867
2868     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2869     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2870             (LONG_PTR)test_proc, proc);
2871
2872     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2873     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2874             (LONG_PTR)test_proc, proc);
2875
2876     hr = reset_device(device, device_window, TRUE);
2877     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
2878
2879     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
2880     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2881             (LONG_PTR)test_proc, proc);
2882
2883     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
2884     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
2885             (LONG_PTR)test_proc, proc);
2886
2887     filter_messages = device_window;
2888
2889     ref = IDirect3DDevice9_Release(device);
2890     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
2891
2892 done:
2893     filter_messages = NULL;
2894     IDirect3D9_Release(d3d9);
2895
2896     SetEvent(thread_params.test_finished);
2897     WaitForSingleObject(thread, INFINITE);
2898     CloseHandle(thread_params.test_finished);
2899     CloseHandle(thread_params.window_created);
2900     CloseHandle(thread);
2901
2902     DestroyWindow(device_window);
2903     DestroyWindow(focus_window);
2904     UnregisterClassA("d3d9_test_wndproc_wc", GetModuleHandleA(NULL));
2905 }
2906
2907 static void test_reset_fullscreen(void)
2908 {
2909     WNDCLASSEX wc = {0};
2910     IDirect3DDevice9 *device = NULL;
2911     IDirect3D9 *d3d = NULL;
2912     ATOM atom;
2913     static const struct message messages[] =
2914     {
2915         {WM_ACTIVATEAPP,    FOCUS_WINDOW},
2916         {0,                     0},
2917     };
2918
2919     d3d = pDirect3DCreate9(D3D_SDK_VERSION);
2920     ok(d3d != NULL, "Failed to create an IDirect3D object.\n");
2921     expect_messages = messages;
2922
2923     wc.cbSize = sizeof(WNDCLASSEX);
2924     wc.lpfnWndProc = test_proc;
2925     wc.lpszClassName = "test_reset_fullscreen";
2926
2927     atom = RegisterClassEx(&wc);
2928     ok(atom, "Failed to register a new window class. GetLastError:%d\n", GetLastError());
2929
2930     device_window = focus_window = CreateWindowEx(0, wc.lpszClassName, "Test Reset Fullscreen", 0, 0, 0, screen_width, screen_height, NULL, NULL, NULL, NULL);
2931     ok(device_window != NULL, "Failed to create a window. GetLastError:%d\n", GetLastError());
2932
2933     /*
2934      * Create a device in windowed mode.
2935      * Since the device is windowed and we haven't called any methods that
2936      * could show the window (such as ShowWindow or SetWindowPos) yet,
2937      * WM_ACTIVATEAPP will not have been sent.
2938      */
2939     device = create_device(d3d, device_window, focus_window, TRUE);
2940     if (!device)
2941     {
2942         skip("Unable to create device.  Skipping test.\n");
2943         goto cleanup;
2944     }
2945
2946     /*
2947      * Switch to fullscreen mode.
2948      * This will force the window to be shown and will cause the WM_ACTIVATEAPP
2949      * message to be sent.
2950      */
2951     ok(SUCCEEDED(reset_device(device, device_window, FALSE)), "Failed to reset device.\n");
2952
2953     flush_events();
2954     ok(expect_messages->message == 0, "Expected to receive message %#x.\n", expect_messages->message);
2955     expect_messages = NULL;
2956
2957 cleanup:
2958     if (device) IDirect3DDevice9_Release(device);
2959     if (d3d) IDirect3D9_Release(d3d);
2960     DestroyWindow(device_window);
2961     device_window = focus_window = NULL;
2962     UnregisterClass(wc.lpszClassName, GetModuleHandle(NULL));
2963 }
2964
2965
2966 static inline void set_fpu_cw(WORD cw)
2967 {
2968 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
2969 #define D3D9_TEST_SET_FPU_CW 1
2970     __asm__ volatile ("fnclex");
2971     __asm__ volatile ("fldcw %0" : : "m" (cw));
2972 #elif defined(__i386__) && defined(_MSC_VER)
2973 #define D3D9_TEST_SET_FPU_CW 1
2974     __asm fnclex;
2975     __asm fldcw cw;
2976 #endif
2977 }
2978
2979 static inline WORD get_fpu_cw(void)
2980 {
2981     WORD cw = 0;
2982 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
2983 #define D3D9_TEST_GET_FPU_CW 1
2984     __asm__ volatile ("fnstcw %0" : "=m" (cw));
2985 #elif defined(__i386__) && defined(_MSC_VER)
2986 #define D3D9_TEST_GET_FPU_CW 1
2987     __asm fnstcw cw;
2988 #endif
2989     return cw;
2990 }
2991
2992 static void test_fpu_setup(void)
2993 {
2994 #if defined(D3D9_TEST_SET_FPU_CW) && defined(D3D9_TEST_GET_FPU_CW)
2995     D3DPRESENT_PARAMETERS present_parameters;
2996     IDirect3DDevice9 *device;
2997     HWND window = NULL;
2998     IDirect3D9 *d3d9;
2999     HRESULT hr;
3000     WORD cw;
3001
3002     d3d9 = pDirect3DCreate9(D3D_SDK_VERSION);
3003     ok(!!d3d9, "Failed to create a d3d9 object.\n");
3004     if (!d3d9) return;
3005
3006     window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
3007     ok(!!window, "Failed to create a window.\n");
3008     if (!window) goto done;
3009
3010     memset(&present_parameters, 0, sizeof(present_parameters));
3011     present_parameters.Windowed = TRUE;
3012     present_parameters.hDeviceWindow = window;
3013     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
3014
3015     set_fpu_cw(0xf60);
3016     cw = get_fpu_cw();
3017     ok(cw == 0xf60, "cw is %#x, expected 0xf60.\n", cw);
3018
3019     hr = IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
3020             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
3021     if (FAILED(hr))
3022     {
3023         skip("Failed to create a device, hr %#x.\n", hr);
3024         set_fpu_cw(0x37f);
3025         goto done;
3026     }
3027
3028     cw = get_fpu_cw();
3029     ok(cw == 0x7f, "cw is %#x, expected 0x7f.\n", cw);
3030
3031     IDirect3DDevice9_Release(device);
3032
3033     cw = get_fpu_cw();
3034     ok(cw == 0x7f, "cw is %#x, expected 0x7f.\n", cw);
3035     set_fpu_cw(0xf60);
3036     cw = get_fpu_cw();
3037     ok(cw == 0xf60, "cw is %#x, expected 0xf60.\n", cw);
3038
3039     hr = IDirect3D9_CreateDevice(d3d9, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
3040             D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE, &present_parameters, &device);
3041     ok(SUCCEEDED(hr), "CreateDevice failed, hr %#x.\n", hr);
3042
3043     cw = get_fpu_cw();
3044     ok(cw == 0xf60, "cw is %#x, expected 0xf60.\n", cw);
3045     set_fpu_cw(0x37f);
3046
3047     IDirect3DDevice9_Release(device);
3048
3049 done:
3050     if (window) DestroyWindow(window);
3051     if (d3d9) IDirect3D9_Release(d3d9);
3052 #endif
3053 }
3054
3055 static void test_window_style(void)
3056 {
3057     RECT focus_rect, fullscreen_rect, r;
3058     LONG device_style, device_exstyle;
3059     LONG focus_style, focus_exstyle;
3060     LONG style, expected_style;
3061     IDirect3DDevice9 *device;
3062     IDirect3D9 *d3d9;
3063     ULONG ref;
3064
3065
3066     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
3067     {
3068         skip("Failed to create IDirect3D9 object, skipping tests.\n");
3069         return;
3070     }
3071
3072     focus_window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3073             0, 0, screen_width / 2, screen_height / 2, 0, 0, 0, 0);
3074     device_window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3075             0, 0, screen_width / 2, screen_height / 2, 0, 0, 0, 0);
3076
3077     device_style = GetWindowLongA(device_window, GWL_STYLE);
3078     device_exstyle = GetWindowLongA(device_window, GWL_EXSTYLE);
3079     focus_style = GetWindowLongA(focus_window, GWL_STYLE);
3080     focus_exstyle = GetWindowLongA(focus_window, GWL_EXSTYLE);
3081
3082     SetRect(&fullscreen_rect, 0, 0, screen_width, screen_height);
3083     GetWindowRect(focus_window, &focus_rect);
3084
3085     device = create_device(d3d9, device_window, focus_window, FALSE);
3086     if (!device)
3087     {
3088         skip("Failed to create a D3D device, skipping tests.\n");
3089         goto done;
3090     }
3091
3092     style = GetWindowLongA(device_window, GWL_STYLE);
3093     expected_style = device_style | WS_VISIBLE;
3094     todo_wine ok(style == expected_style, "Expected device window style %#x, got %#x.\n",
3095             expected_style, style);
3096     style = GetWindowLongA(device_window, GWL_EXSTYLE);
3097     expected_style = device_exstyle | WS_EX_TOPMOST;
3098     todo_wine ok(style == expected_style, "Expected device window extended style %#x, got %#x.\n",
3099             expected_style, style);
3100
3101     style = GetWindowLongA(focus_window, GWL_STYLE);
3102     ok(style == focus_style, "Expected focus window style %#x, got %#x.\n",
3103             focus_style, style);
3104     style = GetWindowLongA(focus_window, GWL_EXSTYLE);
3105     ok(style == focus_exstyle, "Expected focus window extended style %#x, got %#x.\n",
3106             focus_exstyle, style);
3107
3108     GetWindowRect(device_window, &r);
3109     ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3110             fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
3111             r.left, r.top, r.right, r.bottom);
3112     GetClientRect(device_window, &r);
3113     todo_wine ok(!EqualRect(&r, &fullscreen_rect), "Client rect and window rect are equal.\n");
3114     GetWindowRect(focus_window, &r);
3115     ok(EqualRect(&r, &focus_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3116             focus_rect.left, focus_rect.top, focus_rect.right, focus_rect.bottom,
3117             r.left, r.top, r.right, r.bottom);
3118
3119     ref = IDirect3DDevice9_Release(device);
3120     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
3121
3122 done:
3123     IDirect3D9_Release(d3d9);
3124
3125     DestroyWindow(device_window);
3126     DestroyWindow(focus_window);
3127 }
3128
3129 static const POINT *expect_pos;
3130
3131 static LRESULT CALLBACK test_cursor_proc(HWND window, UINT message, WPARAM wparam, LPARAM lparam)
3132 {
3133     if (message == WM_MOUSEMOVE)
3134     {
3135         if (expect_pos && expect_pos->x && expect_pos->y)
3136         {
3137             POINT p = {GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam)};
3138
3139             ClientToScreen(window, &p);
3140             if (expect_pos->x == p.x && expect_pos->y == p.y)
3141                 ++expect_pos;
3142         }
3143     }
3144
3145     return DefWindowProcA(window, message, wparam, lparam);
3146 }
3147
3148 static void test_cursor_pos(void)
3149 {
3150     IDirect3DSurface9 *cursor;
3151     IDirect3DDevice9 *device;
3152     WNDCLASSA wc = {0};
3153     IDirect3D9 *d3d9;
3154     UINT refcount;
3155     HWND window;
3156     HRESULT hr;
3157     BOOL ret;
3158
3159     /* Note that we don't check for movement we're not supposed to receive.
3160      * That's because it's hard to distinguish from the user accidentally
3161      * moving the mouse. */
3162     static const POINT points[] =
3163     {
3164         {50, 50},
3165         {75, 75},
3166         {100, 100},
3167         {125, 125},
3168         {150, 150},
3169         {125, 125},
3170         {150, 150},
3171         {150, 150},
3172         {0, 0},
3173     };
3174
3175     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
3176     {
3177         skip("Failed to create IDirect3D9 object, skipping cursor tests.\n");
3178         return;
3179     }
3180
3181     wc.lpfnWndProc = test_cursor_proc;
3182     wc.lpszClassName = "d3d9_test_cursor_wc";
3183     ok(RegisterClassA(&wc), "Failed to register window class.\n");
3184     window = CreateWindow("d3d9_test_cursor_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3185             0, 0, 320, 240, NULL, NULL, NULL, NULL);
3186     ShowWindow(window, SW_SHOW);
3187
3188     device = create_device(d3d9, window, window, TRUE);
3189     if (!device)
3190     {
3191         skip("Failed to create a D3D device, skipping tests.\n");
3192         goto done;
3193     }
3194
3195     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32,
3196             D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &cursor, NULL);
3197     ok(SUCCEEDED(hr), "Failed to create cursor surface, hr %#x.\n", hr);
3198     hr = IDirect3DDevice9_SetCursorProperties(device, 0, 0, cursor);
3199     ok(SUCCEEDED(hr), "Failed to set cursor properties, hr %#x.\n", hr);
3200     IDirect3DSurface9_Release(cursor);
3201     ret = IDirect3DDevice9_ShowCursor(device, TRUE);
3202     ok(!ret, "Failed to show cursor, hr %#x.\n", ret);
3203
3204     flush_events();
3205     expect_pos = points;
3206
3207     ret = SetCursorPos(50, 50);
3208     ok(ret, "Failed to set cursor position.\n");
3209     flush_events();
3210
3211     IDirect3DDevice9_SetCursorPosition(device, 75, 75, 0);
3212     flush_events();
3213     /* SetCursorPosition() eats duplicates. */
3214     IDirect3DDevice9_SetCursorPosition(device, 75, 75, 0);
3215     flush_events();
3216
3217     ret = SetCursorPos(100, 100);
3218     ok(ret, "Failed to set cursor position.\n");
3219     flush_events();
3220     /* Even if the position was set with SetCursorPos(). */
3221     IDirect3DDevice9_SetCursorPosition(device, 100, 100, 0);
3222     flush_events();
3223
3224     IDirect3DDevice9_SetCursorPosition(device, 125, 125, 0);
3225     flush_events();
3226     ret = SetCursorPos(150, 150);
3227     ok(ret, "Failed to set cursor position.\n");
3228     flush_events();
3229     IDirect3DDevice9_SetCursorPosition(device, 125, 125, 0);
3230     flush_events();
3231
3232     IDirect3DDevice9_SetCursorPosition(device, 150, 150, 0);
3233     flush_events();
3234     /* SetCursorPos() doesn't. */
3235     ret = SetCursorPos(150, 150);
3236     ok(ret, "Failed to set cursor position.\n");
3237     flush_events();
3238
3239     ok(!expect_pos->x && !expect_pos->y, "Didn't receive MOUSEMOVE %u (%d, %d).\n",
3240        (unsigned)(expect_pos - points), expect_pos->x, expect_pos->y);
3241
3242     refcount = IDirect3DDevice9_Release(device);
3243     ok(!refcount, "Device has %u references left.\n", refcount);
3244 done:
3245     DestroyWindow(window);
3246     UnregisterClassA("d3d9_test_cursor_wc", GetModuleHandleA(NULL));
3247     if (d3d9)
3248         IDirect3D9_Release(d3d9);
3249 }
3250
3251 static void test_mode_change(void)
3252 {
3253     RECT fullscreen_rect, focus_rect, r;
3254     IDirect3DSurface9 *backbuffer;
3255     IDirect3DDevice9 *device;
3256     D3DSURFACE_DESC desc;
3257     IDirect3D9 *d3d9;
3258     DEVMODEW devmode;
3259     UINT refcount;
3260     HRESULT hr;
3261     DWORD ret;
3262
3263     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
3264     {
3265         skip("Failed to create IDirect3D9 object, skipping mode change tests.\n");
3266         return;
3267     }
3268
3269     focus_window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3270             0, 0, screen_width / 2, screen_height / 2, 0, 0, 0, 0);
3271     device_window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3272             0, 0, screen_width / 2, screen_height / 2, 0, 0, 0, 0);
3273
3274     SetRect(&fullscreen_rect, 0, 0, screen_width, screen_height);
3275     GetWindowRect(focus_window, &focus_rect);
3276
3277     device = create_device(d3d9, device_window, focus_window, FALSE);
3278     if (!device)
3279     {
3280         skip("Failed to create a D3D device, skipping tests.\n");
3281         goto done;
3282     }
3283
3284     memset(&devmode, 0, sizeof(devmode));
3285     devmode.dmSize = sizeof(devmode);
3286     devmode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
3287     devmode.dmPelsWidth = 640;
3288     devmode.dmPelsHeight = 480;
3289
3290     ret = ChangeDisplaySettingsW(&devmode, CDS_FULLSCREEN);
3291     ok(ret == DISP_CHANGE_SUCCESSFUL, "Failed to change display mode, ret %#x.\n", ret);
3292
3293     memset(&devmode, 0, sizeof(devmode));
3294     devmode.dmSize = sizeof(devmode);
3295     ret = EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &devmode);
3296     ok(ret, "Failed to get display mode.\n");
3297     ok(devmode.dmPelsWidth == 640, "Got unexpect width %u.\n", devmode.dmPelsWidth);
3298     ok(devmode.dmPelsHeight == 480, "Got unexpect height %u.\n", devmode.dmPelsHeight);
3299
3300     GetWindowRect(device_window, &r);
3301     ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3302             fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
3303             r.left, r.top, r.right, r.bottom);
3304     GetWindowRect(focus_window, &r);
3305     ok(EqualRect(&r, &focus_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3306             focus_rect.left, focus_rect.top, focus_rect.right, focus_rect.bottom,
3307             r.left, r.top, r.right, r.bottom);
3308
3309     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
3310     ok(SUCCEEDED(hr), "Failed to get backbuffer, hr %#x.\n", hr);
3311     hr = IDirect3DSurface9_GetDesc(backbuffer, &desc);
3312     ok(SUCCEEDED(hr), "Failed to get backbuffer desc, hr %#x.\n", hr);
3313     ok(desc.Width == screen_width, "Got unexpected backbuffer width %u.\n", desc.Width);
3314     ok(desc.Height == screen_height, "Got unexpected backbuffer height %u.\n", desc.Height);
3315     IDirect3DSurface9_Release(backbuffer);
3316
3317     refcount = IDirect3DDevice9_Release(device);
3318     ok(!refcount, "Device has %u references left.\n", refcount);
3319
3320     memset(&devmode, 0, sizeof(devmode));
3321     devmode.dmSize = sizeof(devmode);
3322     ret = EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &devmode);
3323     ok(ret, "Failed to get display mode.\n");
3324     ok(devmode.dmPelsWidth == screen_width, "Got unexpect width %u.\n", devmode.dmPelsWidth);
3325     ok(devmode.dmPelsHeight == screen_height, "Got unexpect height %u.\n", devmode.dmPelsHeight);
3326
3327 done:
3328     DestroyWindow(device_window);
3329     DestroyWindow(focus_window);
3330     if (d3d9)
3331         IDirect3D9_Release(d3d9);
3332
3333     memset(&devmode, 0, sizeof(devmode));
3334     devmode.dmSize = sizeof(devmode);
3335     ret = EnumDisplaySettingsW(NULL, ENUM_CURRENT_SETTINGS, &devmode);
3336     ok(ret, "Failed to get display mode.\n");
3337     ok(devmode.dmPelsWidth == screen_width, "Got unexpect width %u.\n", devmode.dmPelsWidth);
3338     ok(devmode.dmPelsHeight == screen_height, "Got unexpect height %u.\n", devmode.dmPelsHeight);
3339 }
3340
3341 static void test_device_window_reset(void)
3342 {
3343     RECT fullscreen_rect, device_rect, r;
3344     IDirect3DDevice9 *device;
3345     WNDCLASSA wc = {0};
3346     IDirect3D9 *d3d9;
3347     LONG_PTR proc;
3348     HRESULT hr;
3349     ULONG ref;
3350
3351     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
3352     {
3353         skip("Failed to create IDirect3D9 object, skipping tests.\n");
3354         return;
3355     }
3356
3357     wc.lpfnWndProc = test_proc;
3358     wc.lpszClassName = "d3d9_test_wndproc_wc";
3359     ok(RegisterClassA(&wc), "Failed to register window class.\n");
3360
3361     focus_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3362             0, 0, screen_width / 2, screen_height / 2, 0, 0, 0, 0);
3363     device_window = CreateWindowA("d3d9_test_wndproc_wc", "d3d9_test", WS_OVERLAPPEDWINDOW,
3364             0, 0, screen_width / 2, screen_height / 2, 0, 0, 0, 0);
3365
3366     SetRect(&fullscreen_rect, 0, 0, screen_width, screen_height);
3367     GetWindowRect(device_window, &device_rect);
3368
3369     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
3370     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
3371             (LONG_PTR)test_proc, proc);
3372     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
3373     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
3374             (LONG_PTR)test_proc, proc);
3375
3376     device = create_device(d3d9, NULL, focus_window, FALSE);
3377     if (!device)
3378     {
3379         skip("Failed to create a D3D device, skipping tests.\n");
3380         goto done;
3381     }
3382
3383     GetWindowRect(focus_window, &r);
3384     ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3385             fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
3386             r.left, r.top, r.right, r.bottom);
3387     GetWindowRect(device_window, &r);
3388     ok(EqualRect(&r, &device_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3389             device_rect.left, device_rect.top, device_rect.right, device_rect.bottom,
3390             r.left, r.top, r.right, r.bottom);
3391
3392     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
3393     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
3394             (LONG_PTR)test_proc, proc);
3395     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
3396     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
3397             (LONG_PTR)test_proc, proc);
3398
3399     hr = reset_device(device, device_window, FALSE);
3400     ok(SUCCEEDED(hr), "Failed to reset device.\n");
3401
3402     GetWindowRect(focus_window, &r);
3403     ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3404             fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
3405             r.left, r.top, r.right, r.bottom);
3406     GetWindowRect(device_window, &r);
3407     ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
3408             fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
3409             r.left, r.top, r.right, r.bottom);
3410
3411     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
3412     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
3413             (LONG_PTR)test_proc, proc);
3414     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
3415     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
3416             (LONG_PTR)test_proc, proc);
3417
3418     ref = IDirect3DDevice9_Release(device);
3419     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
3420
3421 done:
3422     IDirect3D9_Release(d3d9);
3423     DestroyWindow(device_window);
3424     DestroyWindow(focus_window);
3425     UnregisterClassA("d3d9_test_wndproc_wc", GetModuleHandleA(NULL));
3426 }
3427
3428 static void test_reset_resources(void)
3429 {
3430     IDirect3DSurface9 *surface, *rt;
3431     IDirect3DTexture9 *texture;
3432     IDirect3DDevice9 *device;
3433     IDirect3D9 *d3d9;
3434     unsigned int i;
3435     D3DCAPS9 caps;
3436     HWND window;
3437     HRESULT hr;
3438     ULONG ref;
3439
3440     window = CreateWindowA("static", "d3d9_test", WS_OVERLAPPEDWINDOW,
3441             0, 0, 640, 480, 0, 0, 0, 0);
3442
3443     if (!(d3d9 = pDirect3DCreate9(D3D_SDK_VERSION)))
3444     {
3445         skip("Failed to create IDirect3D9 object, skipping tests.\n");
3446         DestroyWindow(window);
3447         return;
3448     }
3449
3450     if (!(device = create_device(d3d9, window, window, TRUE)))
3451     {
3452         skip("Failed to create a D3D device, skipping tests.\n");
3453         goto done;
3454     }
3455
3456     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
3457     ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
3458
3459     hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_DEPTHSTENCIL,
3460             D3DFMT_D24S8, D3DPOOL_DEFAULT, &texture, NULL);
3461     ok(SUCCEEDED(hr), "Failed to create depth/stencil texture, hr %#x.\n", hr);
3462     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
3463     ok(SUCCEEDED(hr), "Failed to get surface, hr %#x.\n", hr);
3464     IDirect3DTexture9_Release(texture);
3465     hr = IDirect3DDevice9_SetDepthStencilSurface(device, surface);
3466     ok(SUCCEEDED(hr), "Failed to set depth/stencil surface, hr %#x.\n", hr);
3467     IDirect3DSurface9_Release(surface);
3468
3469     for (i = 0; i < caps.NumSimultaneousRTs; ++i)
3470     {
3471         hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET,
3472                 D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL);
3473         ok(SUCCEEDED(hr), "Failed to create render target texture %u, hr %#x.\n", i, hr);
3474         hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
3475         ok(SUCCEEDED(hr), "Failed to get surface %u, hr %#x.\n", i, hr);
3476         IDirect3DTexture9_Release(texture);
3477         hr = IDirect3DDevice9_SetRenderTarget(device, i, surface);
3478         ok(SUCCEEDED(hr), "Failed to set render target surface %u, hr %#x.\n", i, hr);
3479         IDirect3DSurface9_Release(surface);
3480     }
3481
3482     hr = reset_device(device, device_window, TRUE);
3483     ok(SUCCEEDED(hr), "Failed to reset device.\n");
3484
3485     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &rt);
3486     ok(SUCCEEDED(hr), "Failed to get back buffer, hr %#x.\n", hr);
3487     hr = IDirect3DDevice9_GetRenderTarget(device, 0, &surface);
3488     ok(SUCCEEDED(hr), "Failed to get render target surface, hr %#x.\n", hr);
3489     ok(surface == rt, "Got unexpected surface %p for render target.\n", surface);
3490     IDirect3DSurface9_Release(surface);
3491     IDirect3DSurface9_Release(rt);
3492
3493     for (i = 1; i < caps.NumSimultaneousRTs; ++i)
3494     {
3495         hr = IDirect3DDevice9_GetRenderTarget(device, i, &surface);
3496         ok(hr == D3DERR_NOTFOUND, "Got unexpected hr %#x.\n", hr);
3497     }
3498
3499     ref = IDirect3DDevice9_Release(device);
3500     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
3501
3502 done:
3503     IDirect3D9_Release(d3d9);
3504     DestroyWindow(window);
3505 }
3506
3507 START_TEST(device)
3508 {
3509     HMODULE d3d9_handle = LoadLibraryA( "d3d9.dll" );
3510     WNDCLASS wc = {0};
3511
3512     wc.lpfnWndProc = DefWindowProc;
3513     wc.lpszClassName = "d3d9_test_wc";
3514     RegisterClass(&wc);
3515
3516     if (!d3d9_handle)
3517     {
3518         skip("Could not load d3d9.dll\n");
3519         goto out;
3520     }
3521
3522     pDirect3DCreate9 = (void *)GetProcAddress( d3d9_handle, "Direct3DCreate9" );
3523     ok(pDirect3DCreate9 != NULL, "Failed to get address of Direct3DCreate9\n");
3524     if (pDirect3DCreate9)
3525     {
3526         IDirect3D9 *d3d9 = pDirect3DCreate9( D3D_SDK_VERSION );
3527         if(!d3d9)
3528         {
3529             skip("could not create D3D9 object\n");
3530             goto out;
3531         }
3532         IDirect3D9_Release(d3d9);
3533
3534         screen_width = GetSystemMetrics(SM_CXSCREEN);
3535         screen_height = GetSystemMetrics(SM_CYSCREEN);
3536
3537         test_fpu_setup();
3538         test_multi_device();
3539         test_display_formats();
3540         test_display_modes();
3541         test_swapchain();
3542         test_refcount();
3543         test_mipmap_levels();
3544         test_checkdevicemultisampletype();
3545         test_cursor();
3546         test_cursor_pos();
3547         test_reset_fullscreen();
3548         test_reset();
3549         test_scene();
3550         test_limits();
3551         test_depthstenciltest();
3552         test_get_rt();
3553         test_draw_indexed();
3554         test_null_stream();
3555         test_lights();
3556         test_set_stream_source();
3557         test_scissor_size();
3558         test_wndproc();
3559         test_wndproc_windowed();
3560         test_window_style();
3561         test_mode_change();
3562         test_device_window_reset();
3563         test_reset_resources();
3564     }
3565
3566 out:
3567     UnregisterClassA("d3d9_test_wc", GetModuleHandleA(NULL));
3568 }