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

   1 /*
   2  * Copyright (C) 2006 Vitaliy Margolen
   3  * Copyright (C) 2006 Chris Robinson
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21 #include <initguid.h>
  22 #include <d3d8.h>
  23 #include "wine/test.h"
  24
  25 static INT screen_width;
  26 static INT screen_height;
  27
  28 static IDirect3D8 *(WINAPI *pDirect3DCreate8)(UINT);
  29
  30 static BOOL (WINAPI *pGetCursorInfo)(PCURSORINFO);
  31
  32 static const DWORD simple_vs[] = {0xFFFE0101,       /* vs_1_1               */
  33     0x00000009, 0xC0010000, 0x90E40000, 0xA0E40000, /* dp4 oPos.x, v0, c0   */
  34     0x00000009, 0xC0020000, 0x90E40000, 0xA0E40001, /* dp4 oPos.y, v0, c1   */
  35     0x00000009, 0xC0040000, 0x90E40000, 0xA0E40002, /* dp4 oPos.z, v0, c2   */
  36     0x00000009, 0xC0080000, 0x90E40000, 0xA0E40003, /* dp4 oPos.w, v0, c3   */
  37     0x0000FFFF};                                    /* END                  */
  38 static const DWORD simple_ps[] = {0xFFFF0101,                               /* ps_1_1                       */
  39     0x00000051, 0xA00F0001, 0x3F800000, 0x00000000, 0x00000000, 0x00000000, /* def c1 = 1.0, 0.0, 0.0, 0.0  */
  40     0x00000042, 0xB00F0000,                                                 /* tex t0                       */
  41     0x00000008, 0x800F0000, 0xA0E40001, 0xA0E40000,                         /* dp3 r0, c1, c0               */
  42     0x00000005, 0x800F0000, 0x90E40000, 0x80E40000,                         /* mul r0, v0, r0               */
  43     0x00000005, 0x800F0000, 0xB0E40000, 0x80E40000,                         /* mul r0, t0, r0               */
  44     0x0000FFFF};                                                            /* END                          */
  45
  46 static int get_refcount(IUnknown *object)
  47 {
  48     IUnknown_AddRef( object );
  49     return IUnknown_Release( object );
  50 }
  51
  52 /* try to make sure pending X events have been processed before continuing */
  53 static void flush_events(void)
  54 {
  55     MSG msg;
  56     int diff = 200;
  57     int min_timeout = 100;
  58     DWORD time = GetTickCount() + diff;
  59
  60     while (diff > 0)
  61     {
  62         if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
  63         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
  64         diff = time - GetTickCount();
  65     }
  66 }
  67
  68 static IDirect3DDevice8 *create_device(IDirect3D8 *d3d8, HWND device_window, HWND focus_window, BOOL windowed)
  69 {
  70     D3DPRESENT_PARAMETERS present_parameters = {0};
  71     IDirect3DDevice8 *device;
  72
  73     present_parameters.Windowed = windowed;
  74     present_parameters.hDeviceWindow = device_window;
  75     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
  76     present_parameters.BackBufferWidth = screen_width;
  77     present_parameters.BackBufferHeight = screen_height;
  78     present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
  79     present_parameters.EnableAutoDepthStencil = TRUE;
  80     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
  81
  82     if (SUCCEEDED(IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, focus_window,
  83             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device))) return device;
  84
  85     present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
  86     if (SUCCEEDED(IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, focus_window,
  87             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device))) return device;
  88
  89     if (SUCCEEDED(IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, focus_window,
  90             D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device))) return device;
  91
  92     return NULL;
  93 }
  94
  95 static HRESULT reset_device(IDirect3DDevice8 *device, HWND device_window, BOOL windowed)
  96 {
  97     D3DPRESENT_PARAMETERS present_parameters = {0};
  98
  99     present_parameters.Windowed = windowed;
 100     present_parameters.hDeviceWindow = device_window;
 101     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
 102     present_parameters.BackBufferWidth = screen_width;
 103     present_parameters.BackBufferHeight = screen_height;
 104     present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
 105     present_parameters.EnableAutoDepthStencil = TRUE;
 106     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
 107
 108     return IDirect3DDevice8_Reset(device, &present_parameters);
 109 }
 110
 111 #define CHECK_CALL(r,c,d,rc) \
 112     if (SUCCEEDED(r)) {\
 113         int tmp1 = get_refcount( (IUnknown *)d ); \
 114         int rc_new = rc; \
 115         ok(tmp1 == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, tmp1); \
 116     } else {\
 117         trace("%s failed: %#08x\n", c, r); \
 118     }
 119
 120 #define CHECK_RELEASE(obj,d,rc) \
 121     if (obj) { \
 122         int tmp1, rc_new = rc; \
 123         IUnknown_Release( obj ); \
 124         tmp1 = get_refcount( (IUnknown *)d ); \
 125         ok(tmp1 == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, tmp1); \
 126     }
 127
 128 #define CHECK_REFCOUNT(obj,rc) \
 129     { \
 130         int rc_new = rc; \
 131         int count = get_refcount( (IUnknown *)obj ); \
 132         ok(count == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, count); \
 133     }
 134
 135 #define CHECK_RELEASE_REFCOUNT(obj,rc) \
 136     { \
 137         int rc_new = rc; \
 138         int count = IUnknown_Release( (IUnknown *)obj ); \
 139         ok(count == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, count); \
 140     }
 141
 142 #define CHECK_ADDREF_REFCOUNT(obj,rc) \
 143     { \
 144         int rc_new = rc; \
 145         int count = IUnknown_AddRef( (IUnknown *)obj ); \
 146         ok(count == rc_new, "Invalid refcount. Expected %d got %d\n", rc_new, count); \
 147     }
 148
 149 #define CHECK_SURFACE_CONTAINER(obj,iid,expected) \
 150     { \
 151         void *container_ptr = (void *)0x1337c0d3; \
 152         hr = IDirect3DSurface8_GetContainer(obj, &iid, &container_ptr); \
 153         ok(SUCCEEDED(hr) && container_ptr == expected, "GetContainer returned: hr %#08x, container_ptr %p. " \
 154             "Expected hr %#08x, container_ptr %p\n", hr, container_ptr, S_OK, expected); \
 155         if (container_ptr && container_ptr != (void *)0x1337c0d3) IUnknown_Release((IUnknown *)container_ptr); \
 156     }
 157
 158 static void check_mipmap_levels(IDirect3DDevice8 *device, UINT width, UINT height, UINT count)
 159 {
 160     IDirect3DBaseTexture8* texture = NULL;
 161     HRESULT hr = IDirect3DDevice8_CreateTexture( device, width, height, 0, 0,
 162             D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, (IDirect3DTexture8**) &texture );
 163
 164     if (SUCCEEDED(hr)) {
 165         DWORD levels = IDirect3DBaseTexture8_GetLevelCount(texture);
 166         ok(levels == count, "Invalid level count. Expected %d got %u\n", count, levels);
 167     } else
 168         trace("CreateTexture failed: %#08x\n", hr);
 169
 170     if (texture) IUnknown_Release( texture );
 171 }
 172
 173 static void test_mipmap_levels(void)
 174 {
 175
 176     HRESULT               hr;
 177     HWND                  hwnd = NULL;
 178
 179     IDirect3D8            *pD3d = NULL;
 180     IDirect3DDevice8      *pDevice = NULL;
 181     D3DPRESENT_PARAMETERS d3dpp;
 182     D3DDISPLAYMODE        d3ddm;
 183
 184     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 185     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 186     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 187     ok(hwnd != NULL, "Failed to create window\n");
 188     if (!pD3d || !hwnd) goto cleanup;
 189
 190     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 191     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 192     d3dpp.Windowed         = TRUE;
 193     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 194     d3dpp.BackBufferFormat = d3ddm.Format;
 195
 196     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 197                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 198     if(FAILED(hr))
 199     {
 200         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
 201         goto cleanup;
 202     }
 203
 204     check_mipmap_levels(pDevice, 32, 32, 6);
 205     check_mipmap_levels(pDevice, 256, 1, 9);
 206     check_mipmap_levels(pDevice, 1, 256, 9);
 207     check_mipmap_levels(pDevice, 1, 1, 1);
 208
 209 cleanup:
 210     if (pDevice)
 211     {
 212         UINT refcount = IUnknown_Release( pDevice );
 213         ok(!refcount, "Device has %u references left.\n", refcount);
 214     }
 215     if (pD3d) IUnknown_Release( pD3d );
 216     DestroyWindow( hwnd );
 217 }
 218
 219 static void test_swapchain(void)
 220 {
 221     HRESULT                      hr;
 222     HWND                         hwnd               = NULL;
 223     IDirect3D8                  *pD3d               = NULL;
 224     IDirect3DDevice8            *pDevice            = NULL;
 225     IDirect3DSwapChain8         *swapchain1         = NULL;
 226     IDirect3DSwapChain8         *swapchain2         = NULL;
 227     IDirect3DSwapChain8         *swapchain3         = NULL;
 228     IDirect3DSurface8           *backbuffer         = NULL;
 229     D3DPRESENT_PARAMETERS        d3dpp;
 230     D3DDISPLAYMODE               d3ddm;
 231
 232     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 233     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 234     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 235     ok(hwnd != NULL, "Failed to create window\n");
 236     if (!pD3d || !hwnd) goto cleanup;
 237
 238     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 239     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 240     d3dpp.Windowed         = TRUE;
 241     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 242     d3dpp.BackBufferFormat = d3ddm.Format;
 243     d3dpp.BackBufferCount  = 0;
 244
 245     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 246                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 247     if(FAILED(hr))
 248     {
 249         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
 250         goto cleanup;
 251     }
 252
 253     /* Check if the back buffer count was modified */
 254     ok(d3dpp.BackBufferCount == 1, "The back buffer count in the presentparams struct is %d\n", d3dpp.BackBufferCount);
 255
 256     /* Create a bunch of swapchains */
 257     d3dpp.BackBufferCount = 0;
 258     hr = IDirect3DDevice8_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain1);
 259     ok(SUCCEEDED(hr), "Failed to create a swapchain (%#08x)\n", hr);
 260     ok(d3dpp.BackBufferCount == 1, "The back buffer count in the presentparams struct is %d\n", d3dpp.BackBufferCount);
 261
 262     d3dpp.BackBufferCount  = 1;
 263     hr = IDirect3DDevice8_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain2);
 264     ok(SUCCEEDED(hr), "Failed to create a swapchain (%#08x)\n", hr);
 265
 266     d3dpp.BackBufferCount  = 2;
 267     hr = IDirect3DDevice8_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain3);
 268     ok(SUCCEEDED(hr), "Failed to create a swapchain (%#08x)\n", hr);
 269     if(SUCCEEDED(hr)) {
 270         /* Swapchain 3, created with backbuffercount 2 */
 271         backbuffer = (void *) 0xdeadbeef;
 272         hr = IDirect3DSwapChain8_GetBackBuffer(swapchain3, 0, 0, &backbuffer);
 273         ok(SUCCEEDED(hr), "Failed to get the 1st back buffer (%#08x)\n", hr);
 274         ok(backbuffer != NULL && backbuffer != (void *) 0xdeadbeef, "The back buffer is %p\n", backbuffer);
 275         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 276
 277         backbuffer = (void *) 0xdeadbeef;
 278         hr = IDirect3DSwapChain8_GetBackBuffer(swapchain3, 1, 0, &backbuffer);
 279         ok(SUCCEEDED(hr), "Failed to get the 2nd back buffer (%#08x)\n", hr);
 280         ok(backbuffer != NULL && backbuffer != (void *) 0xdeadbeef, "The back buffer is %p\n", backbuffer);
 281         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 282
 283         backbuffer = (void *) 0xdeadbeef;
 284         hr = IDirect3DSwapChain8_GetBackBuffer(swapchain3, 2, 0, &backbuffer);
 285         ok(hr == D3DERR_INVALIDCALL, "GetBackBuffer returned %#08x\n", hr);
 286         ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 287         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 288
 289         backbuffer = (void *) 0xdeadbeef;
 290         hr = IDirect3DSwapChain8_GetBackBuffer(swapchain3, 3, 0, &backbuffer);
 291         ok(FAILED(hr), "Failed to get the back buffer (%#08x)\n", hr);
 292         ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 293         if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 294     }
 295
 296     /* Check the back buffers of the swapchains */
 297     /* Swapchain 1, created with backbuffercount 0 */
 298     hr = IDirect3DSwapChain8_GetBackBuffer(swapchain1, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
 299     ok(SUCCEEDED(hr), "Failed to get the back buffer (%#08x)\n", hr);
 300     ok(backbuffer != NULL, "The back buffer is NULL (%#08x)\n", hr);
 301     if(backbuffer) IDirect3DSurface8_Release(backbuffer);
 302
 303     backbuffer = (void *) 0xdeadbeef;
 304     hr = IDirect3DSwapChain8_GetBackBuffer(swapchain1, 1, 0, &backbuffer);
 305     ok(FAILED(hr), "Failed to get the back buffer (%#08x)\n", hr);
 306     ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 307     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 308
 309     /* Swapchain 2 - created with backbuffercount 1 */
 310     backbuffer = (void *) 0xdeadbeef;
 311     hr = IDirect3DSwapChain8_GetBackBuffer(swapchain2, 0, 0, &backbuffer);
 312     ok(SUCCEEDED(hr), "Failed to get the back buffer (%#08x)\n", hr);
 313     ok(backbuffer != NULL && backbuffer != (void *) 0xdeadbeef, "The back buffer is %p\n", backbuffer);
 314     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 315
 316     backbuffer = (void *) 0xdeadbeef;
 317     hr = IDirect3DSwapChain8_GetBackBuffer(swapchain2, 1, 0, &backbuffer);
 318     ok(hr == D3DERR_INVALIDCALL, "GetBackBuffer returned %#08x\n", hr);
 319     ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 320     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 321
 322     backbuffer = (void *) 0xdeadbeef;
 323     hr = IDirect3DSwapChain8_GetBackBuffer(swapchain2, 2, 0, &backbuffer);
 324     ok(FAILED(hr), "Failed to get the back buffer (%#08x)\n", hr);
 325     ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
 326     if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
 327
 328 cleanup:
 329     if(swapchain1) IDirect3DSwapChain8_Release(swapchain1);
 330     if(swapchain2) IDirect3DSwapChain8_Release(swapchain2);
 331     if(swapchain3) IDirect3DSwapChain8_Release(swapchain3);
 332     if (pDevice)
 333     {
 334         UINT refcount = IDirect3DDevice8_Release(pDevice);
 335         ok(!refcount, "Device has %u references left.\n", refcount);
 336     }
 337     if (pD3d) IDirect3D8_Release(pD3d);
 338     DestroyWindow( hwnd );
 339 }
 340
 341 static void test_refcount(void)
 342 {
 343     HRESULT                      hr;
 344     HWND                         hwnd               = NULL;
 345     IDirect3D8                  *pD3d               = NULL;
 346     IDirect3DDevice8            *pDevice            = NULL;
 347     IDirect3DVertexBuffer8      *pVertexBuffer      = NULL;
 348     IDirect3DIndexBuffer8       *pIndexBuffer       = NULL;
 349     DWORD                       dVertexShader       = -1;
 350     DWORD                       dPixelShader        = -1;
 351     IDirect3DCubeTexture8       *pCubeTexture       = NULL;
 352     IDirect3DTexture8           *pTexture           = NULL;
 353     IDirect3DVolumeTexture8     *pVolumeTexture     = NULL;
 354     IDirect3DVolume8            *pVolumeLevel       = NULL;
 355     IDirect3DSurface8           *pStencilSurface    = NULL;
 356     IDirect3DSurface8           *pImageSurface      = NULL;
 357     IDirect3DSurface8           *pRenderTarget      = NULL;
 358     IDirect3DSurface8           *pRenderTarget2     = NULL;
 359     IDirect3DSurface8           *pRenderTarget3     = NULL;
 360     IDirect3DSurface8           *pTextureLevel      = NULL;
 361     IDirect3DSurface8           *pBackBuffer        = NULL;
 362     DWORD                       dStateBlock         = -1;
 363     IDirect3DSwapChain8         *pSwapChain         = NULL;
 364     D3DCAPS8                    caps;
 365
 366     D3DPRESENT_PARAMETERS        d3dpp;
 367     D3DDISPLAYMODE               d3ddm;
 368     int                          refcount = 0, tmp;
 369
 370     DWORD decl[] =
 371     {
 372         D3DVSD_STREAM(0),
 373         D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3),  /* D3DVSDE_POSITION, Register v0 */
 374         D3DVSD_REG(D3DVSDE_DIFFUSE, D3DVSDT_D3DCOLOR), /* D3DVSDE_DIFFUSE, Register v5 */
 375         D3DVSD_END()
 376     };
 377
 378     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 379     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 380     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 381     ok(hwnd != NULL, "Failed to create window\n");
 382     if (!pD3d || !hwnd) goto cleanup;
 383
 384     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 385     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 386     d3dpp.Windowed         = TRUE;
 387     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 388     d3dpp.BackBufferFormat = d3ddm.Format;
 389     d3dpp.EnableAutoDepthStencil = TRUE;
 390     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
 391
 392     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 393                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 394     if(FAILED(hr))
 395     {
 396         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
 397         goto cleanup;
 398     }
 399     IDirect3DDevice8_GetDeviceCaps(pDevice, &caps);
 400
 401     refcount = get_refcount( (IUnknown *)pDevice );
 402     ok(refcount == 1, "Invalid device RefCount %d\n", refcount);
 403
 404     /**
 405      * Check refcount of implicit surfaces. Findings:
 406      *   - the container is the device
 407      *   - they hold a reference to the device
 408      *   - they are created with a refcount of 0 (Get/Release returns original refcount)
 409      *   - they are not freed if refcount reaches 0.
 410      *   - the refcount is not forwarded to the container.
 411      */
 412     hr = IDirect3DDevice8_GetRenderTarget(pDevice, &pRenderTarget);
 413     CHECK_CALL( hr, "GetRenderTarget", pDevice, ++refcount);
 414     if(pRenderTarget)
 415     {
 416         CHECK_SURFACE_CONTAINER( pRenderTarget, IID_IDirect3DDevice8, pDevice);
 417         CHECK_REFCOUNT( pRenderTarget, 1);
 418
 419         CHECK_ADDREF_REFCOUNT(pRenderTarget, 2);
 420         CHECK_REFCOUNT(pDevice, refcount);
 421         CHECK_RELEASE_REFCOUNT(pRenderTarget, 1);
 422         CHECK_REFCOUNT(pDevice, refcount);
 423
 424         hr = IDirect3DDevice8_GetRenderTarget(pDevice, &pRenderTarget);
 425         CHECK_CALL( hr, "GetRenderTarget", pDevice, refcount);
 426         CHECK_REFCOUNT( pRenderTarget, 2);
 427         CHECK_RELEASE_REFCOUNT( pRenderTarget, 1);
 428         CHECK_RELEASE_REFCOUNT( pRenderTarget, 0);
 429         CHECK_REFCOUNT( pDevice, --refcount);
 430
 431         /* The render target is released with the device, so AddRef with refcount=0 is fine here. */
 432         CHECK_ADDREF_REFCOUNT(pRenderTarget, 1);
 433         CHECK_REFCOUNT(pDevice, ++refcount);
 434         CHECK_RELEASE_REFCOUNT(pRenderTarget, 0);
 435         CHECK_REFCOUNT(pDevice, --refcount);
 436     }
 437
 438     /* Render target and back buffer are identical. */
 439     hr = IDirect3DDevice8_GetBackBuffer(pDevice, 0, 0, &pBackBuffer);
 440     CHECK_CALL( hr, "GetBackBuffer", pDevice, ++refcount);
 441     if(pBackBuffer)
 442     {
 443         CHECK_RELEASE_REFCOUNT(pBackBuffer, 0);
 444         ok(pRenderTarget == pBackBuffer, "RenderTarget=%p and BackBuffer=%p should be the same.\n",
 445            pRenderTarget, pBackBuffer);
 446         pBackBuffer = NULL;
 447     }
 448     CHECK_REFCOUNT( pDevice, --refcount);
 449
 450     hr = IDirect3DDevice8_GetDepthStencilSurface(pDevice, &pStencilSurface);
 451     CHECK_CALL( hr, "GetDepthStencilSurface", pDevice, ++refcount);
 452     if(pStencilSurface)
 453     {
 454         CHECK_SURFACE_CONTAINER( pStencilSurface, IID_IDirect3DDevice8, pDevice);
 455         CHECK_REFCOUNT( pStencilSurface, 1);
 456
 457         CHECK_ADDREF_REFCOUNT(pStencilSurface, 2);
 458         CHECK_REFCOUNT(pDevice, refcount);
 459         CHECK_RELEASE_REFCOUNT(pStencilSurface, 1);
 460         CHECK_REFCOUNT(pDevice, refcount);
 461
 462         CHECK_RELEASE_REFCOUNT( pStencilSurface, 0);
 463         CHECK_REFCOUNT( pDevice, --refcount);
 464
 465         /* The stencil surface is released with the device, so AddRef with refcount=0 is fine here. */
 466         CHECK_ADDREF_REFCOUNT(pStencilSurface, 1);
 467         CHECK_REFCOUNT(pDevice, ++refcount);
 468         CHECK_RELEASE_REFCOUNT(pStencilSurface, 0);
 469         CHECK_REFCOUNT(pDevice, --refcount);
 470         pStencilSurface = NULL;
 471     }
 472
 473     /* Buffers */
 474     hr = IDirect3DDevice8_CreateIndexBuffer( pDevice, 16, 0, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &pIndexBuffer );
 475     CHECK_CALL( hr, "CreateIndexBuffer", pDevice, ++refcount );
 476     if(pIndexBuffer)
 477     {
 478         tmp = get_refcount( (IUnknown *)pIndexBuffer );
 479
 480         hr = IDirect3DDevice8_SetIndices(pDevice, pIndexBuffer, 0);
 481         CHECK_CALL( hr, "SetIndices", pIndexBuffer, tmp);
 482         hr = IDirect3DDevice8_SetIndices(pDevice, NULL, 0);
 483         CHECK_CALL( hr, "SetIndices", pIndexBuffer, tmp);
 484     }
 485
 486     hr = IDirect3DDevice8_CreateVertexBuffer( pDevice, 16, 0, D3DFVF_XYZ, D3DPOOL_DEFAULT, &pVertexBuffer );
 487     CHECK_CALL( hr, "CreateVertexBuffer", pDevice, ++refcount );
 488     if(pVertexBuffer)
 489     {
 490         IDirect3DVertexBuffer8 *pVBuf = (void*)~0;
 491         UINT stride = ~0;
 492
 493         tmp = get_refcount( (IUnknown *)pVertexBuffer );
 494
 495         hr = IDirect3DDevice8_SetStreamSource(pDevice, 0, pVertexBuffer, 3 * sizeof(float));
 496         CHECK_CALL( hr, "SetStreamSource", pVertexBuffer, tmp);
 497         hr = IDirect3DDevice8_SetStreamSource(pDevice, 0, NULL, 0);
 498         CHECK_CALL( hr, "SetStreamSource", pVertexBuffer, tmp);
 499
 500         hr = IDirect3DDevice8_GetStreamSource(pDevice, 0, &pVBuf, &stride);
 501         ok(SUCCEEDED(hr), "GetStreamSource did not succeed with NULL stream!\n");
 502         ok(pVBuf==NULL, "pVBuf not NULL (%p)!\n", pVBuf);
 503         ok(stride==3*sizeof(float), "stride not 3 floats (got %u)!\n", stride);
 504     }
 505
 506     /* Shaders */
 507     hr = IDirect3DDevice8_CreateVertexShader( pDevice, decl, simple_vs, &dVertexShader, 0 );
 508     CHECK_CALL( hr, "CreateVertexShader", pDevice, refcount );
 509     if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 0))
 510     {
 511         hr = IDirect3DDevice8_CreatePixelShader( pDevice, simple_ps, &dPixelShader );
 512         CHECK_CALL( hr, "CreatePixelShader", pDevice, refcount );
 513     }
 514     /* Textures */
 515     hr = IDirect3DDevice8_CreateTexture( pDevice, 32, 32, 3, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pTexture );
 516     CHECK_CALL( hr, "CreateTexture", pDevice, ++refcount );
 517     if (pTexture)
 518     {
 519         tmp = get_refcount( (IUnknown *)pTexture );
 520
 521         /* SetTexture should not increase refcounts */
 522         hr = IDirect3DDevice8_SetTexture(pDevice, 0, (IDirect3DBaseTexture8 *) pTexture);
 523         CHECK_CALL( hr, "SetTexture", pTexture, tmp);
 524         hr = IDirect3DDevice8_SetTexture(pDevice, 0, NULL);
 525         CHECK_CALL( hr, "SetTexture", pTexture, tmp);
 526
 527         /* This should not increment device refcount */
 528         hr = IDirect3DTexture8_GetSurfaceLevel( pTexture, 1, &pTextureLevel );
 529         CHECK_CALL( hr, "GetSurfaceLevel", pDevice, refcount );
 530         /* But should increment texture's refcount */
 531         CHECK_REFCOUNT( pTexture, tmp+1 );
 532         /* Because the texture and surface refcount are identical */
 533         if (pTextureLevel)
 534         {
 535             CHECK_REFCOUNT        ( pTextureLevel, tmp+1 );
 536             CHECK_ADDREF_REFCOUNT ( pTextureLevel, tmp+2 );
 537             CHECK_REFCOUNT        ( pTexture     , tmp+2 );
 538             CHECK_RELEASE_REFCOUNT( pTextureLevel, tmp+1 );
 539             CHECK_REFCOUNT        ( pTexture     , tmp+1 );
 540             CHECK_RELEASE_REFCOUNT( pTexture     , tmp   );
 541             CHECK_REFCOUNT        ( pTextureLevel, tmp   );
 542         }
 543     }
 544     if(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
 545     {
 546         hr = IDirect3DDevice8_CreateCubeTexture( pDevice, 32, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pCubeTexture );
 547         CHECK_CALL( hr, "CreateCubeTexture", pDevice, ++refcount );
 548     }
 549     else
 550     {
 551         skip("Cube textures not supported\n");
 552     }
 553     if(caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
 554     {
 555         hr = IDirect3DDevice8_CreateVolumeTexture( pDevice, 32, 32, 2, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pVolumeTexture );
 556         CHECK_CALL( hr, "CreateVolumeTexture", pDevice, ++refcount );
 557     }
 558     else
 559     {
 560         skip("Volume textures not supported\n");
 561     }
 562
 563     if (pVolumeTexture)
 564     {
 565         tmp = get_refcount( (IUnknown *)pVolumeTexture );
 566
 567         /* This should not increment device refcount */
 568         hr = IDirect3DVolumeTexture8_GetVolumeLevel(pVolumeTexture, 0, &pVolumeLevel);
 569         CHECK_CALL( hr, "GetVolumeLevel", pDevice, refcount );
 570         /* But should increment volume texture's refcount */
 571         CHECK_REFCOUNT( pVolumeTexture, tmp+1 );
 572         /* Because the volume texture and volume refcount are identical */
 573         if (pVolumeLevel)
 574         {
 575             CHECK_REFCOUNT        ( pVolumeLevel  , tmp+1 );
 576             CHECK_ADDREF_REFCOUNT ( pVolumeLevel  , tmp+2 );
 577             CHECK_REFCOUNT        ( pVolumeTexture, tmp+2 );
 578             CHECK_RELEASE_REFCOUNT( pVolumeLevel  , tmp+1 );
 579             CHECK_REFCOUNT        ( pVolumeTexture, tmp+1 );
 580             CHECK_RELEASE_REFCOUNT( pVolumeTexture, tmp   );
 581             CHECK_REFCOUNT        ( pVolumeLevel  , tmp   );
 582         }
 583     }
 584     /* Surfaces */
 585     hr = IDirect3DDevice8_CreateDepthStencilSurface( pDevice, 32, 32, D3DFMT_D16, D3DMULTISAMPLE_NONE, &pStencilSurface );
 586     CHECK_CALL( hr, "CreateDepthStencilSurface", pDevice, ++refcount );
 587     CHECK_REFCOUNT( pStencilSurface, 1);
 588     hr = IDirect3DDevice8_CreateImageSurface( pDevice, 32, 32, D3DFMT_X8R8G8B8, &pImageSurface );
 589     CHECK_CALL( hr, "CreateImageSurface", pDevice, ++refcount );
 590     CHECK_REFCOUNT( pImageSurface, 1);
 591     hr = IDirect3DDevice8_CreateRenderTarget( pDevice, 32, 32, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, TRUE, &pRenderTarget3 );
 592     CHECK_CALL( hr, "CreateRenderTarget", pDevice, ++refcount );
 593     CHECK_REFCOUNT( pRenderTarget3, 1);
 594     /* Misc */
 595     hr = IDirect3DDevice8_CreateStateBlock( pDevice, D3DSBT_ALL, &dStateBlock );
 596     CHECK_CALL( hr, "CreateStateBlock", pDevice, refcount );
 597     hr = IDirect3DDevice8_CreateAdditionalSwapChain( pDevice, &d3dpp, &pSwapChain );
 598     CHECK_CALL( hr, "CreateAdditionalSwapChain", pDevice, ++refcount );
 599     if(pSwapChain)
 600     {
 601         /* check implicit back buffer */
 602         hr = IDirect3DSwapChain8_GetBackBuffer(pSwapChain, 0, 0, &pBackBuffer);
 603         CHECK_CALL( hr, "GetBackBuffer", pDevice, ++refcount);
 604         CHECK_REFCOUNT( pSwapChain, 1);
 605         if(pBackBuffer)
 606         {
 607             CHECK_SURFACE_CONTAINER( pBackBuffer, IID_IDirect3DDevice8, pDevice);
 608             CHECK_REFCOUNT( pBackBuffer, 1);
 609             CHECK_RELEASE_REFCOUNT( pBackBuffer, 0);
 610             CHECK_REFCOUNT( pDevice, --refcount);
 611
 612             /* The back buffer is released with the swapchain, so AddRef with refcount=0 is fine here. */
 613             CHECK_ADDREF_REFCOUNT(pBackBuffer, 1);
 614             CHECK_REFCOUNT(pDevice, ++refcount);
 615             CHECK_RELEASE_REFCOUNT(pBackBuffer, 0);
 616             CHECK_REFCOUNT(pDevice, --refcount);
 617             pBackBuffer = NULL;
 618         }
 619         CHECK_REFCOUNT( pSwapChain, 1);
 620     }
 621
 622     if(pVertexBuffer)
 623     {
 624         BYTE *data;
 625         /* Vertex buffers can be locked multiple times */
 626         hr = IDirect3DVertexBuffer8_Lock(pVertexBuffer, 0, 0, &data, 0);
 627         ok(hr == D3D_OK, "IDirect3DVertexBuffer8::Lock failed with %#08x\n", hr);
 628         hr = IDirect3DVertexBuffer8_Lock(pVertexBuffer, 0, 0, &data, 0);
 629         ok(hr == D3D_OK, "IDirect3DVertexBuffer8::Lock failed with %#08x\n", hr);
 630         hr = IDirect3DVertexBuffer8_Unlock(pVertexBuffer);
 631         ok(hr == D3D_OK, "IDirect3DVertexBuffer8::Unlock failed with %#08x\n", hr);
 632         hr = IDirect3DVertexBuffer8_Unlock(pVertexBuffer);
 633         ok(hr == D3D_OK, "IDirect3DVertexBuffer8::Unlock failed with %#08x\n", hr);
 634     }
 635
 636     /* The implicit render target is not freed if refcount reaches 0.
 637      * Otherwise GetRenderTarget would re-allocate it and the pointer would change.*/
 638     hr = IDirect3DDevice8_GetRenderTarget(pDevice, &pRenderTarget2);
 639     CHECK_CALL( hr, "GetRenderTarget", pDevice, ++refcount);
 640     if(pRenderTarget2)
 641     {
 642         CHECK_RELEASE_REFCOUNT(pRenderTarget2, 0);
 643         ok(pRenderTarget == pRenderTarget2, "RenderTarget=%p and RenderTarget2=%p should be the same.\n",
 644            pRenderTarget, pRenderTarget2);
 645         CHECK_REFCOUNT( pDevice, --refcount);
 646         pRenderTarget2 = NULL;
 647     }
 648     pRenderTarget = NULL;
 649
 650 cleanup:
 651     CHECK_RELEASE(pDevice,              pDevice, --refcount);
 652
 653     /* Buffers */
 654     CHECK_RELEASE(pVertexBuffer,        pDevice, --refcount);
 655     CHECK_RELEASE(pIndexBuffer,         pDevice, --refcount);
 656     /* Shaders */
 657     if (dVertexShader != ~0U) IDirect3DDevice8_DeleteVertexShader( pDevice, dVertexShader );
 658     if (dPixelShader != ~0U) IDirect3DDevice8_DeletePixelShader( pDevice, dPixelShader );
 659     /* Textures */
 660     CHECK_RELEASE(pTexture,             pDevice, --refcount);
 661     CHECK_RELEASE(pCubeTexture,         pDevice, --refcount);
 662     CHECK_RELEASE(pVolumeTexture,       pDevice, --refcount);
 663     /* Surfaces */
 664     CHECK_RELEASE(pStencilSurface,      pDevice, --refcount);
 665     CHECK_RELEASE(pImageSurface,        pDevice, --refcount);
 666     CHECK_RELEASE(pRenderTarget3,       pDevice, --refcount);
 667     /* Misc */
 668     if (dStateBlock != ~0U) IDirect3DDevice8_DeleteStateBlock( pDevice, dStateBlock );
 669     /* This will destroy device - cannot check the refcount here */
 670     if (pSwapChain)           CHECK_RELEASE_REFCOUNT( pSwapChain, 0);
 671
 672     if (pD3d)                 CHECK_RELEASE_REFCOUNT( pD3d, 0);
 673
 674     DestroyWindow( hwnd );
 675 }
 676
 677 static void test_cursor(void)
 678 {
 679     HRESULT                      hr;
 680     HWND                         hwnd               = NULL;
 681     IDirect3D8                  *pD3d               = NULL;
 682     IDirect3DDevice8            *pDevice            = NULL;
 683     D3DPRESENT_PARAMETERS        d3dpp;
 684     D3DDISPLAYMODE               d3ddm;
 685     CURSORINFO                   info;
 686     IDirect3DSurface8 *cursor = NULL;
 687     HCURSOR cur;
 688     HMODULE user32_handle = GetModuleHandleA("user32.dll");
 689
 690     pGetCursorInfo = (void *)GetProcAddress(user32_handle, "GetCursorInfo");
 691     if (!pGetCursorInfo)
 692     {
 693         win_skip("GetCursorInfo is not available\n");
 694         return;
 695     }
 696
 697     memset(&info, 0, sizeof(info));
 698     info.cbSize = sizeof(info);
 699     ok(pGetCursorInfo(&info), "GetCursorInfo failed\n");
 700     cur = info.hCursor;
 701
 702     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 703     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 704     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 705     ok(hwnd != NULL, "Failed to create window\n");
 706     if (!pD3d || !hwnd) goto cleanup;
 707
 708     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 709     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 710     d3dpp.Windowed         = TRUE;
 711     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 712     d3dpp.BackBufferFormat = d3ddm.Format;
 713
 714     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
 715                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 716     if(FAILED(hr))
 717     {
 718         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
 719         goto cleanup;
 720     }
 721
 722     IDirect3DDevice8_CreateImageSurface(pDevice, 32, 32, D3DFMT_A8R8G8B8, &cursor);
 723     ok(cursor != NULL, "IDirect3DDevice8_CreateOffscreenPlainSurface failed with %#08x\n", hr);
 724
 725     /* Initially hidden */
 726     hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
 727     ok(hr == FALSE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
 728
 729     /* Not enabled without a surface*/
 730     hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
 731     ok(hr == FALSE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
 732
 733     /* Fails */
 734     hr = IDirect3DDevice8_SetCursorProperties(pDevice, 0, 0, NULL);
 735     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_SetCursorProperties returned %#08x\n", hr);
 736
 737     hr = IDirect3DDevice8_SetCursorProperties(pDevice, 0, 0, cursor);
 738     ok(hr == D3D_OK, "IDirect3DDevice8_SetCursorProperties returned %#08x\n", hr);
 739
 740     IDirect3DSurface8_Release(cursor);
 741
 742     memset(&info, 0, sizeof(info));
 743     info.cbSize = sizeof(info);
 744     ok(pGetCursorInfo(&info), "GetCursorInfo failed\n");
 745     ok(info.flags & CURSOR_SHOWING, "The gdi cursor is hidden (%08x)\n", info.flags);
 746     ok(info.hCursor == cur, "The cursor handle is %p\n", info.hCursor); /* unchanged */
 747
 748     /* Still hidden */
 749     hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
 750     ok(hr == FALSE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
 751
 752     /* Enabled now*/
 753     hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
 754     ok(hr == TRUE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
 755
 756     /* GDI cursor unchanged */
 757     memset(&info, 0, sizeof(info));
 758     info.cbSize = sizeof(info);
 759     ok(pGetCursorInfo(&info), "GetCursorInfo failed\n");
 760     ok(info.flags & CURSOR_SHOWING, "The gdi cursor is hidden (%08x)\n", info.flags);
 761     ok(info.hCursor == cur, "The cursor handle is %p\n", info.hCursor); /* unchanged */
 762
 763 cleanup:
 764     if (pDevice)
 765     {
 766         UINT refcount = IDirect3DDevice8_Release(pDevice);
 767         ok(!refcount, "Device has %u references left.\n", refcount);
 768     }
 769     if (pD3d) IDirect3D8_Release(pD3d);
 770 }
 771
 772 static void test_states(void)
 773 {
 774     HRESULT                      hr;
 775     HWND                         hwnd               = NULL;
 776     IDirect3D8                  *pD3d               = NULL;
 777     IDirect3DDevice8            *pDevice            = NULL;
 778     D3DPRESENT_PARAMETERS        d3dpp;
 779     D3DDISPLAYMODE               d3ddm;
 780
 781     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 782     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 783     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 784     ok(hwnd != NULL, "Failed to create window\n");
 785     if (!pD3d || !hwnd) goto cleanup;
 786
 787     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 788     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 789     d3dpp.Windowed         = TRUE;
 790     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 791     d3dpp.BackBufferWidth  = screen_width;
 792     d3dpp.BackBufferHeight = screen_height;
 793     d3dpp.BackBufferFormat = d3ddm.Format;
 794
 795     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
 796                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 797     if(FAILED(hr))
 798     {
 799         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
 800         goto cleanup;
 801     }
 802
 803     hr = IDirect3DDevice8_SetRenderState(pDevice, D3DRS_ZVISIBLE, TRUE);
 804     ok(hr == D3D_OK, "IDirect3DDevice8_SetRenderState(D3DRS_ZVISIBLE, TRUE) returned %#08x\n", hr);
 805     hr = IDirect3DDevice8_SetRenderState(pDevice, D3DRS_ZVISIBLE, FALSE);
 806     ok(hr == D3D_OK, "IDirect3DDevice8_SetRenderState(D3DRS_ZVISIBLE, FALSE) returned %#08x\n", hr);
 807
 808 cleanup:
 809     if (pDevice)
 810     {
 811         UINT refcount = IDirect3DDevice8_Release(pDevice);
 812         ok(!refcount, "Device has %u references left.\n", refcount);
 813     }
 814     if (pD3d) IDirect3D8_Release(pD3d);
 815 }
 816
 817 static void test_shader_versions(void)
 818 {
 819     HRESULT                      hr;
 820     IDirect3D8                  *pD3d               = NULL;
 821     D3DCAPS8                     d3dcaps;
 822
 823     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 824     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 825     if (pD3d != NULL) {
 826         hr = IDirect3D8_GetDeviceCaps(pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dcaps);
 827         ok(SUCCEEDED(hr) || hr == D3DERR_NOTAVAILABLE, "Failed to get D3D8 caps (%#08x)\n", hr);
 828         if (SUCCEEDED(hr)) {
 829             ok(d3dcaps.VertexShaderVersion <= D3DVS_VERSION(1,1), "Unexpected VertexShaderVersion (%#x > %#x)\n", d3dcaps.VertexShaderVersion, D3DVS_VERSION(1,1));
 830             ok(d3dcaps.PixelShaderVersion <= D3DPS_VERSION(1,4), "Unexpected PixelShaderVersion (%#x > %#x)\n", d3dcaps.PixelShaderVersion, D3DPS_VERSION(1,4));
 831         } else {
 832             skip("No Direct3D support\n");
 833         }
 834         IDirect3D8_Release(pD3d);
 835     }
 836 }
 837
 838
 839 /* Test adapter display modes */
 840 static void test_display_modes(void)
 841 {
 842     UINT max_modes, i;
 843     D3DDISPLAYMODE dmode;
 844     HRESULT res;
 845     IDirect3D8 *pD3d;
 846
 847     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 848     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 849     if(!pD3d) return;
 850
 851     max_modes = IDirect3D8_GetAdapterModeCount(pD3d, D3DADAPTER_DEFAULT);
 852     ok(max_modes > 0 ||
 853        broken(max_modes == 0), /* VMware */
 854        "GetAdapterModeCount(D3DADAPTER_DEFAULT) returned 0!\n");
 855
 856     for(i=0; i<max_modes;i++) {
 857         res = IDirect3D8_EnumAdapterModes(pD3d, D3DADAPTER_DEFAULT, i, &dmode);
 858         ok(res==D3D_OK, "EnumAdapterModes returned %#08x for mode %u!\n", res, i);
 859         if(res != D3D_OK)
 860             continue;
 861
 862         ok(dmode.Format==D3DFMT_X8R8G8B8 || dmode.Format==D3DFMT_R5G6B5,
 863            "Unexpected display mode returned for mode %u: %#x\n", i , dmode.Format);
 864     }
 865
 866     IDirect3D8_Release(pD3d);
 867 }
 868
 869 static void test_scene(void)
 870 {
 871     HRESULT                      hr;
 872     HWND                         hwnd               = NULL;
 873     IDirect3D8                  *pD3d               = NULL;
 874     IDirect3DDevice8            *pDevice            = NULL;
 875     D3DPRESENT_PARAMETERS        d3dpp;
 876     D3DDISPLAYMODE               d3ddm;
 877
 878     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 879     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 880     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 881     ok(hwnd != NULL, "Failed to create window\n");
 882     if (!pD3d || !hwnd) goto cleanup;
 883
 884     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 885     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 886     d3dpp.Windowed         = TRUE;
 887     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 888     d3dpp.BackBufferWidth  = 800;
 889     d3dpp.BackBufferHeight = 600;
 890     d3dpp.BackBufferFormat = d3ddm.Format;
 891
 892
 893     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
 894                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
 895     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
 896     if(!pDevice)
 897     {
 898         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
 899         goto cleanup;
 900     }
 901
 902     /* Test an EndScene without beginscene. Should return an error */
 903     hr = IDirect3DDevice8_EndScene(pDevice);
 904     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_EndScene returned %#08x\n", hr);
 905
 906     /* Test a normal BeginScene / EndScene pair, this should work */
 907     hr = IDirect3DDevice8_BeginScene(pDevice);
 908     ok(hr == D3D_OK, "IDirect3DDevice8_BeginScene failed with %#08x\n", hr);
 909     if(SUCCEEDED(hr))
 910     {
 911         hr = IDirect3DDevice8_EndScene(pDevice);
 912         ok(hr == D3D_OK, "IDirect3DDevice8_EndScene failed with %#08x\n", hr);
 913     }
 914
 915     /* Test another EndScene without having begun a new scene. Should return an error */
 916     hr = IDirect3DDevice8_EndScene(pDevice);
 917     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_EndScene returned %#08x\n", hr);
 918
 919     /* Two nested BeginScene and EndScene calls */
 920     hr = IDirect3DDevice8_BeginScene(pDevice);
 921     ok(hr == D3D_OK, "IDirect3DDevice8_BeginScene failed with %#08x\n", hr);
 922     hr = IDirect3DDevice8_BeginScene(pDevice);
 923     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_BeginScene returned %#08x\n", hr);
 924     hr = IDirect3DDevice8_EndScene(pDevice);
 925     ok(hr == D3D_OK, "IDirect3DDevice8_EndScene failed with %#08x\n", hr);
 926     hr = IDirect3DDevice8_EndScene(pDevice);
 927     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_EndScene returned %#08x\n", hr);
 928
 929     /* StretchRect does not exit in Direct3D8, so no equivalent to the d3d9 stretchrect tests */
 930
 931 cleanup:
 932     if (pDevice)
 933     {
 934         UINT refcount = IDirect3DDevice8_Release(pDevice);
 935         ok(!refcount, "Device has %u references left.\n", refcount);
 936     }
 937     if (pD3d) IDirect3D8_Release(pD3d);
 938     if(hwnd) DestroyWindow(hwnd);
 939 }
 940
 941 static void test_shader(void)
 942 {
 943     HRESULT                      hr;
 944     HWND                         hwnd               = NULL;
 945     IDirect3D8                  *pD3d               = NULL;
 946     IDirect3DDevice8            *pDevice            = NULL;
 947     D3DPRESENT_PARAMETERS        d3dpp;
 948     D3DDISPLAYMODE               d3ddm;
 949     DWORD                        hPixelShader = 0, hVertexShader = 0;
 950     DWORD                        hPixelShader2 = 0, hVertexShader2 = 0;
 951     DWORD                        hTempHandle;
 952     D3DCAPS8                     caps;
 953     DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
 954     DWORD data_size;
 955     void *data;
 956
 957     static DWORD dwVertexDecl[] =
 958     {
 959         D3DVSD_STREAM(0),
 960         D3DVSD_REG(D3DVSDE_POSITION,  D3DVSDT_FLOAT3),
 961         D3DVSD_END()
 962     };
 963     DWORD decl_normal_float2[] =
 964     {
 965         D3DVSD_STREAM(0),
 966         D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3),  /* D3DVSDE_POSITION, Register v0 */
 967         D3DVSD_REG(D3DVSDE_NORMAL,   D3DVSDT_FLOAT2),  /* D3DVSDE_NORMAL,   Register v1 */
 968         D3DVSD_END()
 969     };
 970     DWORD decl_normal_float4[] =
 971     {
 972         D3DVSD_STREAM(0),
 973         D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3),  /* D3DVSDE_POSITION, Register v0 */
 974         D3DVSD_REG(D3DVSDE_NORMAL,   D3DVSDT_FLOAT4),  /* D3DVSDE_NORMAL,   Register v1 */
 975         D3DVSD_END()
 976     };
 977     DWORD decl_normal_d3dcolor[] =
 978     {
 979         D3DVSD_STREAM(0),
 980         D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3),  /* D3DVSDE_POSITION, Register v0 */
 981         D3DVSD_REG(D3DVSDE_NORMAL,   D3DVSDT_D3DCOLOR),/* D3DVSDE_NORMAL,   Register v1 */
 982         D3DVSD_END()
 983     };
 984     const DWORD vertex_decl_size = sizeof(dwVertexDecl);
 985     const DWORD simple_vs_size = sizeof(simple_vs);
 986     const DWORD simple_ps_size = sizeof(simple_ps);
 987
 988     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
 989     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
 990     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
 991     ok(hwnd != NULL, "Failed to create window\n");
 992     if (!pD3d || !hwnd) goto cleanup;
 993
 994     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
 995     ZeroMemory( &d3dpp, sizeof(d3dpp) );
 996     d3dpp.Windowed         = TRUE;
 997     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
 998     d3dpp.BackBufferWidth  = 800;
 999     d3dpp.BackBufferHeight = 600;
1000     d3dpp.BackBufferFormat = d3ddm.Format;
1001
1002
1003     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1004                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1005     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
1006     if(!pDevice)
1007     {
1008         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
1009         goto cleanup;
1010     }
1011     IDirect3DDevice8_GetDeviceCaps(pDevice, &caps);
1012
1013     /* Test setting and retrieving a FVF */
1014     hr = IDirect3DDevice8_SetVertexShader(pDevice, fvf);
1015     ok(SUCCEEDED(hr), "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
1016     hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
1017     ok(SUCCEEDED(hr), "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
1018     ok(hTempHandle == fvf, "Vertex shader %#08x is set, expected %#08x\n", hTempHandle, fvf);
1019
1020     /* First create a vertex shader */
1021     hr = IDirect3DDevice8_SetVertexShader(pDevice, 0);
1022     ok(SUCCEEDED(hr), "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
1023     hr = IDirect3DDevice8_CreateVertexShader(pDevice, dwVertexDecl, simple_vs, &hVertexShader, 0);
1024     ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1025     /* Msdn says that the new vertex shader is set immediately. This is wrong, apparently */
1026     hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
1027     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
1028     ok(hTempHandle == 0, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, 0);
1029     /* Assign the shader, then verify that GetVertexShader works */
1030     hr = IDirect3DDevice8_SetVertexShader(pDevice, hVertexShader);
1031     ok(hr == D3D_OK, "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
1032     hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
1033     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
1034     ok(hTempHandle == hVertexShader, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, hVertexShader);
1035     /* Verify that we can retrieve the declaration */
1036     hr = IDirect3DDevice8_GetVertexShaderDeclaration(pDevice, hVertexShader, NULL, &data_size);
1037     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderDeclaration returned %#08x\n", hr);
1038     ok(data_size == vertex_decl_size, "Got data_size %u, expected %u\n", data_size, vertex_decl_size);
1039     data = HeapAlloc(GetProcessHeap(), 0, vertex_decl_size);
1040     data_size = 1;
1041     hr = IDirect3DDevice8_GetVertexShaderDeclaration(pDevice, hVertexShader, data, &data_size);
1042     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_GetVertexShaderDeclaration returned (%#08x), "
1043             "expected D3DERR_INVALIDCALL\n", hr);
1044     ok(data_size == 1, "Got data_size %u, expected 1\n", data_size);
1045     data_size = vertex_decl_size;
1046     hr = IDirect3DDevice8_GetVertexShaderDeclaration(pDevice, hVertexShader, data, &data_size);
1047     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderDeclaration returned %#08x\n", hr);
1048     ok(data_size == vertex_decl_size, "Got data_size %u, expected %u\n", data_size, vertex_decl_size);
1049     ok(!memcmp(data, dwVertexDecl, vertex_decl_size), "data not equal to shader declaration\n");
1050     HeapFree(GetProcessHeap(), 0, data);
1051     /* Verify that we can retrieve the shader function */
1052     hr = IDirect3DDevice8_GetVertexShaderFunction(pDevice, hVertexShader, NULL, &data_size);
1053     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderFunction returned %#08x\n", hr);
1054     ok(data_size == simple_vs_size, "Got data_size %u, expected %u\n", data_size, simple_vs_size);
1055     data = HeapAlloc(GetProcessHeap(), 0, simple_vs_size);
1056     data_size = 1;
1057     hr = IDirect3DDevice8_GetVertexShaderFunction(pDevice, hVertexShader, data, &data_size);
1058     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_GetVertexShaderFunction returned (%#08x), "
1059             "expected D3DERR_INVALIDCALL\n", hr);
1060     ok(data_size == 1, "Got data_size %u, expected 1\n", data_size);
1061     data_size = simple_vs_size;
1062     hr = IDirect3DDevice8_GetVertexShaderFunction(pDevice, hVertexShader, data, &data_size);
1063     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderFunction returned %#08x\n", hr);
1064     ok(data_size == simple_vs_size, "Got data_size %u, expected %u\n", data_size, simple_vs_size);
1065     ok(!memcmp(data, simple_vs, simple_vs_size), "data not equal to shader function\n");
1066     HeapFree(GetProcessHeap(), 0, data);
1067     /* Delete the assigned shader. This is supposed to work */
1068     hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1069     ok(hr == D3D_OK, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
1070     /* The shader should be unset now */
1071     hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
1072     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
1073     ok(hTempHandle == 0, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, 0);
1074
1075     /* Test a broken declaration. 3DMark2001 tries to use normals with 2 components
1076      * First try the fixed function shader function, then a custom one
1077      */
1078     hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_float2, 0, &hVertexShader, 0);
1079     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1080     if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1081     hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_float4, 0, &hVertexShader, 0);
1082     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1083     if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1084     hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_d3dcolor, 0, &hVertexShader, 0);
1085     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1086     if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1087
1088     hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_float2, simple_vs, &hVertexShader, 0);
1089     ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1090     if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1091
1092     if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 0))
1093     {
1094         /* The same with a pixel shader */
1095         hr = IDirect3DDevice8_CreatePixelShader(pDevice, simple_ps, &hPixelShader);
1096         ok(hr == D3D_OK, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
1097         /* Msdn says that the new pixel shader is set immediately. This is wrong, apparently */
1098         hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
1099         ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
1100         ok(hTempHandle == 0, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, 0);
1101         /* Assign the shader, then verify that GetPixelShader works */
1102         hr = IDirect3DDevice8_SetPixelShader(pDevice, hPixelShader);
1103         ok(hr == D3D_OK, "IDirect3DDevice8_SetPixelShader returned %#08x\n", hr);
1104         hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
1105         ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
1106         ok(hTempHandle == hPixelShader, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, hPixelShader);
1107         /* Verify that we can retrieve the shader function */
1108         hr = IDirect3DDevice8_GetPixelShaderFunction(pDevice, hPixelShader, NULL, &data_size);
1109         ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShaderFunction returned %#08x\n", hr);
1110         ok(data_size == simple_ps_size, "Got data_size %u, expected %u\n", data_size, simple_ps_size);
1111         data = HeapAlloc(GetProcessHeap(), 0, simple_ps_size);
1112         data_size = 1;
1113         hr = IDirect3DDevice8_GetPixelShaderFunction(pDevice, hPixelShader, data, &data_size);
1114         ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_GetPixelShaderFunction returned (%#08x), "
1115                 "expected D3DERR_INVALIDCALL\n", hr);
1116         ok(data_size == 1, "Got data_size %u, expected 1\n", data_size);
1117         data_size = simple_ps_size;
1118         hr = IDirect3DDevice8_GetPixelShaderFunction(pDevice, hPixelShader, data, &data_size);
1119         ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShaderFunction returned %#08x\n", hr);
1120         ok(data_size == simple_ps_size, "Got data_size %u, expected %u\n", data_size, simple_ps_size);
1121         ok(!memcmp(data, simple_ps, simple_ps_size), "data not equal to shader function\n");
1122         HeapFree(GetProcessHeap(), 0, data);
1123         /* Delete the assigned shader. This is supposed to work */
1124         hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader);
1125         ok(hr == D3D_OK, "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
1126         /* The shader should be unset now */
1127         hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
1128         ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
1129         ok(hTempHandle == 0, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, 0);
1130
1131         /* What happens if a non-bound shader is deleted? */
1132         hr = IDirect3DDevice8_CreatePixelShader(pDevice, simple_ps, &hPixelShader);
1133         ok(hr == D3D_OK, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
1134         hr = IDirect3DDevice8_CreatePixelShader(pDevice, simple_ps, &hPixelShader2);
1135         ok(hr == D3D_OK, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
1136
1137         hr = IDirect3DDevice8_SetPixelShader(pDevice, hPixelShader);
1138         ok(hr == D3D_OK, "IDirect3DDevice8_SetPixelShader returned %#08x\n", hr);
1139         hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader2);
1140         ok(hr == D3D_OK, "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
1141         hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
1142         ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
1143         ok(hTempHandle == hPixelShader, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, hPixelShader);
1144         hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader);
1145         ok(hr == D3D_OK, "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
1146
1147         /* Check for double delete. */
1148         hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader2);
1149         ok(hr == D3DERR_INVALIDCALL || broken(hr == D3D_OK), "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
1150         hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader);
1151         ok(hr == D3DERR_INVALIDCALL || broken(hr == D3D_OK), "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
1152     }
1153     else
1154     {
1155         skip("Pixel shaders not supported\n");
1156     }
1157
1158     /* What happens if a non-bound shader is deleted? */
1159     hr = IDirect3DDevice8_CreateVertexShader(pDevice, dwVertexDecl, NULL, &hVertexShader, 0);
1160     ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1161     hr = IDirect3DDevice8_CreateVertexShader(pDevice, dwVertexDecl, NULL, &hVertexShader2, 0);
1162     ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
1163
1164     hr = IDirect3DDevice8_SetVertexShader(pDevice, hVertexShader);
1165     ok(hr == D3D_OK, "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
1166     hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader2);
1167     ok(hr == D3D_OK, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
1168     hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
1169     ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
1170     ok(hTempHandle == hVertexShader, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, hVertexShader);
1171     hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1172     ok(hr == D3D_OK, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
1173
1174     /* Check for double delete. */
1175     hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader2);
1176     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
1177     hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
1178     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
1179
1180 cleanup:
1181     if (pDevice)
1182     {
1183         UINT refcount = IDirect3DDevice8_Release(pDevice);
1184         ok(!refcount, "Device has %u references left.\n", refcount);
1185     }
1186     if (pD3d) IDirect3D8_Release(pD3d);
1187     if(hwnd) DestroyWindow(hwnd);
1188 }
1189
1190 static void test_limits(void)
1191 {
1192     HRESULT                      hr;
1193     HWND                         hwnd               = NULL;
1194     IDirect3D8                  *pD3d               = NULL;
1195     IDirect3DDevice8            *pDevice            = NULL;
1196     D3DPRESENT_PARAMETERS        d3dpp;
1197     D3DDISPLAYMODE               d3ddm;
1198     IDirect3DTexture8           *pTexture           = NULL;
1199     int i;
1200
1201     pD3d = pDirect3DCreate8( D3D_SDK_VERSION );
1202     ok(pD3d != NULL, "Failed to create IDirect3D8 object\n");
1203     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1204     ok(hwnd != NULL, "Failed to create window\n");
1205     if (!pD3d || !hwnd) goto cleanup;
1206
1207     IDirect3D8_GetAdapterDisplayMode( pD3d, D3DADAPTER_DEFAULT, &d3ddm );
1208     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1209     d3dpp.Windowed         = TRUE;
1210     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1211     d3dpp.BackBufferWidth  = 800;
1212     d3dpp.BackBufferHeight = 600;
1213     d3dpp.BackBufferFormat = d3ddm.Format;
1214     d3dpp.EnableAutoDepthStencil = TRUE;
1215     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1216
1217     hr = IDirect3D8_CreateDevice( pD3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1218                                   D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
1219     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
1220     if(!pDevice)
1221     {
1222         skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
1223         goto cleanup;
1224     }
1225
1226     hr = IDirect3DDevice8_CreateTexture(pDevice, 16, 16, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pTexture);
1227     ok(hr == D3D_OK, "IDirect3DDevice8_CreateTexture failed with %#08x\n", hr);
1228     if(!pTexture) goto cleanup;
1229
1230     /* There are 8 texture stages. We should be able to access all of them */
1231     for(i = 0; i < 8; i++) {
1232         hr = IDirect3DDevice8_SetTexture(pDevice, i, (IDirect3DBaseTexture8 *) pTexture);
1233         ok(hr == D3D_OK, "IDirect3DDevice8_SetTexture for sampler %d failed with %#08x\n", i, hr);
1234         hr = IDirect3DDevice8_SetTexture(pDevice, i, NULL);
1235         ok(hr == D3D_OK, "IDirect3DDevice8_SetTexture for sampler %d failed with %#08x\n", i, hr);
1236         hr = IDirect3DDevice8_SetTextureStageState(pDevice, i, D3DTSS_COLOROP, D3DTOP_ADD);
1237         ok(hr == D3D_OK, "IDirect3DDevice8_SetTextureStageState for texture %d failed with %#08x\n", i, hr);
1238     }
1239
1240     /* Investigations show that accessing higher textures stage states does not return an error either. Writing
1241      * to too high texture stages(approximately texture 40) causes memory corruption in windows, so there is no
1242      * bounds checking but how do I test that?
1243      */
1244
1245 cleanup:
1246     if(pTexture) IDirect3DTexture8_Release(pTexture);
1247     if (pDevice)
1248     {
1249         UINT refcount = IDirect3DDevice8_Release(pDevice);
1250         ok(!refcount, "Device has %u references left.\n", refcount);
1251     }
1252     if (pD3d) IDirect3D8_Release(pD3d);
1253     if(hwnd) DestroyWindow(hwnd);
1254 }
1255
1256 static void test_lights(void)
1257 {
1258     D3DPRESENT_PARAMETERS d3dpp;
1259     IDirect3DDevice8 *device = NULL;
1260     IDirect3D8 *d3d8;
1261     HWND hwnd;
1262     HRESULT hr;
1263     unsigned int i;
1264     BOOL enabled;
1265     D3DCAPS8 caps;
1266     D3DDISPLAYMODE               d3ddm;
1267
1268     d3d8 = pDirect3DCreate8( D3D_SDK_VERSION );
1269     ok(d3d8 != NULL, "Failed to create IDirect3D8 object\n");
1270     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1271     ok(hwnd != NULL, "Failed to create window\n");
1272     if (!d3d8 || !hwnd) goto cleanup;
1273
1274     IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &d3ddm );
1275     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1276     d3dpp.Windowed         = TRUE;
1277     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1278     d3dpp.BackBufferWidth  = 800;
1279     d3dpp.BackBufferHeight = 600;
1280     d3dpp.BackBufferFormat = d3ddm.Format;
1281     d3dpp.EnableAutoDepthStencil = TRUE;
1282     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1283
1284     hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1285                                   D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &d3dpp, &device );
1286     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
1287        "IDirect3D8_CreateDevice failed with %08x\n", hr);
1288     if(!device)
1289     {
1290         skip("Failed to create a d3d device\n");
1291         goto cleanup;
1292     }
1293
1294     memset(&caps, 0, sizeof(caps));
1295     hr = IDirect3DDevice8_GetDeviceCaps(device, &caps);
1296     ok(hr == D3D_OK, "IDirect3DDevice8_GetDeviceCaps failed with %08x\n", hr);
1297
1298     for(i = 1; i <= caps.MaxActiveLights; i++) {
1299         hr = IDirect3DDevice8_LightEnable(device, i, TRUE);
1300         ok(hr == D3D_OK, "Enabling light %u failed with %08x\n", i, hr);
1301         hr = IDirect3DDevice8_GetLightEnable(device, i, &enabled);
1302         ok(hr == D3D_OK || broken(hr == D3DERR_INVALIDCALL),
1303             "GetLightEnable on light %u failed with %08x\n", i, hr);
1304         ok(enabled, "Light %d is %s\n", i, enabled ? "enabled" : "disabled");
1305     }
1306
1307     /* TODO: Test the rendering results in this situation */
1308     hr = IDirect3DDevice8_LightEnable(device, i + 1, TRUE);
1309     ok(hr == D3D_OK ||
1310        broken(hr == D3DERR_INVALIDCALL), /* Some Win9x and WinME */
1311        "Enabling one light more than supported returned %08x\n", hr);
1312     hr = IDirect3DDevice8_GetLightEnable(device, i + 1, &enabled);
1313     ok(hr == D3D_OK ||
1314        broken(hr == D3DERR_INVALIDCALL), /* Some Win9x and WinME */
1315        "GetLightEnable on light %u failed with %08x\n", i + 1, hr);
1316     ok(enabled, "Light %d is %s\n", i + 1, enabled ? "enabled" : "disabled");
1317     hr = IDirect3DDevice8_LightEnable(device, i + 1, FALSE);
1318     ok(hr == D3D_OK, "Disabling the additional returned %08x\n", hr);
1319
1320     for(i = 1; i <= caps.MaxActiveLights; i++) {
1321         hr = IDirect3DDevice8_LightEnable(device, i, FALSE);
1322         ok(hr == D3D_OK, "Disabling light %u failed with %08x\n", i, hr);
1323     }
1324
1325 cleanup:
1326     if (device)
1327     {
1328         UINT refcount = IDirect3DDevice8_Release(device);
1329         ok(!refcount, "Device has %u references left.\n", refcount);
1330     }
1331     if (d3d8) IDirect3D8_Release(d3d8);
1332 }
1333
1334 static void test_render_zero_triangles(void)
1335 {
1336     D3DPRESENT_PARAMETERS d3dpp;
1337     IDirect3DDevice8 *device = NULL;
1338     IDirect3D8 *d3d8;
1339     HWND hwnd;
1340     HRESULT hr;
1341     D3DDISPLAYMODE               d3ddm;
1342
1343     struct nvertex
1344     {
1345         float x, y, z;
1346         float nx, ny, nz;
1347         DWORD diffuse;
1348     }  quad[] =
1349     {
1350         { 0.0f, -1.0f,   0.1f,  1.0f,   1.0f,   1.0f,   0xff0000ff},
1351         { 0.0f,  0.0f,   0.1f,  1.0f,   1.0f,   1.0f,   0xff0000ff},
1352         { 1.0f,  0.0f,   0.1f,  1.0f,   1.0f,   1.0f,   0xff0000ff},
1353         { 1.0f, -1.0f,   0.1f,  1.0f,   1.0f,   1.0f,   0xff0000ff},
1354     };
1355
1356     d3d8 = pDirect3DCreate8( D3D_SDK_VERSION );
1357     ok(d3d8 != NULL, "Failed to create IDirect3D8 object\n");
1358     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
1359     ok(hwnd != NULL, "Failed to create window\n");
1360     if (!d3d8 || !hwnd) goto cleanup;
1361
1362     IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &d3ddm );
1363     ZeroMemory( &d3dpp, sizeof(d3dpp) );
1364     d3dpp.Windowed         = TRUE;
1365     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1366     d3dpp.BackBufferWidth  = 800;
1367     d3dpp.BackBufferHeight = 600;
1368     d3dpp.BackBufferFormat = d3ddm.Format;
1369     d3dpp.EnableAutoDepthStencil = TRUE;
1370     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
1371
1372     hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
1373                                   D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &d3dpp, &device );
1374     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
1375        "IDirect3D8_CreateDevice failed with %08x\n", hr);
1376     if(!device)
1377     {
1378         skip("Failed to create a d3d device\n");
1379         goto cleanup;
1380     }
1381
1382     hr = IDirect3DDevice8_SetVertexShader(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
1383     ok(hr == D3D_OK, "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
1384
1385     hr = IDirect3DDevice8_BeginScene(device);
1386     ok(hr == D3D_OK, "IDirect3DDevice8_BeginScene failed with %#08x\n", hr);
1387     if(hr == D3D_OK)
1388     {
1389         hr = IDirect3DDevice8_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 0 /* NumVerts */,
1390                                                     0 /*PrimCount */, NULL, D3DFMT_INDEX16, quad, sizeof(quad[0]));
1391         ok(hr == D3D_OK, "IDirect3DDevice8_DrawIndexedPrimitiveUP failed with %#08x\n", hr);
1392
1393         IDirect3DDevice8_EndScene(device);
1394         ok(hr == D3D_OK, "IDirect3DDevice8_EndScene failed with %#08x\n", hr);
1395     }
1396
1397     IDirect3DDevice8_Present(device, NULL, NULL, NULL, NULL);
1398
1399 cleanup:
1400     if (device)
1401     {
1402         UINT refcount = IDirect3DDevice8_Release(device);
1403         ok(!refcount, "Device has %u references left.\n", refcount);
1404     }
1405     if (d3d8) IDirect3D8_Release(d3d8);
1406 }
1407
1408 static void test_depth_stencil_reset(void)
1409 {
1410     D3DPRESENT_PARAMETERS present_parameters;
1411     D3DDISPLAYMODE display_mode;
1412     IDirect3DSurface8 *surface;
1413     IDirect3DDevice8 *device = NULL;
1414     IDirect3D8 *d3d8;
1415     UINT refcount;
1416     HRESULT hr;
1417     HWND hwnd;
1418
1419     d3d8 = pDirect3DCreate8(D3D_SDK_VERSION);
1420     ok(d3d8 != NULL, "Failed to create IDirect3D8 object\n");
1421     hwnd = CreateWindow("static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL);
1422     ok(hwnd != NULL, "Failed to create window\n");
1423     if (!d3d8 || !hwnd) goto cleanup;
1424
1425     IDirect3D8_GetAdapterDisplayMode(d3d8, D3DADAPTER_DEFAULT, &display_mode);
1426     memset(&present_parameters, 0, sizeof(present_parameters));
1427     present_parameters.Windowed               = TRUE;
1428     present_parameters.SwapEffect             = D3DSWAPEFFECT_DISCARD;
1429     present_parameters.BackBufferFormat       = display_mode.Format;
1430     present_parameters.EnableAutoDepthStencil = TRUE;
1431     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
1432
1433     hr = IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
1434             D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device);
1435     if(FAILED(hr))
1436     {
1437         skip("could not create device, IDirect3D8_CreateDevice returned %#x\n", hr);
1438         goto cleanup;
1439     }
1440
1441     hr = IDirect3DDevice8_TestCooperativeLevel(device);
1442     ok(SUCCEEDED(hr), "TestCooperativeLevel failed with %#x\n", hr);
1443
1444     hr = IDirect3DDevice8_SetRenderTarget(device, NULL, NULL);
1445     ok(hr == D3D_OK, "SetRenderTarget failed with 0x%08x\n", hr);
1446
1447     hr = IDirect3DDevice8_GetRenderTarget(device, &surface);
1448     ok(hr == D3D_OK, "GetRenderTarget failed with 0x%08x\n", hr);
1449     ok(surface != NULL, "Render target should not be NULL\n");
1450     if (surface) IDirect3DSurface8_Release(surface);
1451
1452     hr = IDirect3DDevice8_GetDepthStencilSurface(device, &surface);
1453     ok(hr == D3DERR_NOTFOUND, "GetDepthStencilSurface returned 0x%08x, expected D3DERR_NOTFOUND\n", hr);
1454     ok(surface == NULL, "Depth stencil should be NULL\n");
1455
1456     present_parameters.EnableAutoDepthStencil = TRUE;
1457     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
1458     hr = IDirect3DDevice8_Reset(device, &present_parameters);
1459     ok(hr == D3D_OK, "Reset failed with 0x%08x\n", hr);
1460
1461     hr = IDirect3DDevice8_GetDepthStencilSurface(device, &surface);
1462     ok(hr == D3D_OK, "GetDepthStencilSurface failed with 0x%08x\n", hr);
1463     ok(surface != NULL, "Depth stencil should not be NULL\n");
1464     if (surface) IDirect3DSurface8_Release(surface);
1465
1466     present_parameters.EnableAutoDepthStencil = FALSE;
1467     hr = IDirect3DDevice8_Reset(device, &present_parameters);
1468     ok(hr == D3D_OK, "Reset failed with 0x%08x\n", hr);
1469
1470     hr = IDirect3DDevice8_GetDepthStencilSurface(device, &surface);
1471     ok(hr == D3DERR_NOTFOUND, "GetDepthStencilSurface returned 0x%08x, expected D3DERR_NOTFOUND\n", hr);
1472     ok(surface == NULL, "Depth stencil should be NULL\n");
1473
1474     refcount = IDirect3DDevice8_Release(device);
1475     ok(!refcount, "Device has %u references left.\n", refcount);
1476     device = NULL;
1477
1478     IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &display_mode );
1479
1480     ZeroMemory( &present_parameters, sizeof(present_parameters) );
1481     present_parameters.Windowed         = TRUE;
1482     present_parameters.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1483     present_parameters.BackBufferFormat = display_mode.Format;
1484     present_parameters.EnableAutoDepthStencil = FALSE;
1485     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
1486
1487     hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
1488                     D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device );
1489
1490     if(FAILED(hr))
1491     {
1492         skip("could not create device, IDirect3D8_CreateDevice returned %#x\n", hr);
1493         goto cleanup;
1494     }
1495
1496     hr = IDirect3DDevice8_TestCooperativeLevel(device);
1497     ok(hr == D3D_OK, "IDirect3DDevice8_TestCooperativeLevel after creation returned %#x\n", hr);
1498
1499     present_parameters.SwapEffect       = D3DSWAPEFFECT_DISCARD;
1500     present_parameters.Windowed         = TRUE;
1501     present_parameters.BackBufferWidth  = 400;
1502     present_parameters.BackBufferHeight = 300;
1503     present_parameters.EnableAutoDepthStencil = TRUE;
1504     present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
1505
1506     hr = IDirect3DDevice8_Reset(device, &present_parameters);
1507     ok(hr == D3D_OK, "IDirect3DDevice8_Reset failed with 0x%08x\n", hr);
1508
1509     if (FAILED(hr)) goto cleanup;
1510
1511     hr = IDirect3DDevice8_GetDepthStencilSurface(device, &surface);
1512     ok(hr == D3D_OK, "GetDepthStencilSurface failed with 0x%08x\n", hr);
1513     ok(surface != NULL, "Depth stencil should not be NULL\n");
1514     if (surface) IDirect3DSurface8_Release(surface);
1515
1516 cleanup:
1517     if (device)
1518     {
1519         refcount = IDirect3DDevice8_Release(device);
1520         ok(!refcount, "Device has %u references left.\n", refcount);
1521     }
1522     if (d3d8) IDirect3D8_Release(d3d8);
1523 }
1524
1525 static HWND filter_messages;
1526
1527 enum message_window
1528 {
1529     DEVICE_WINDOW,
1530     FOCUS_WINDOW,
1531 };
1532
1533 struct message
1534 {
1535     UINT message;
1536     enum message_window window;
1537 };
1538
1539 static const struct message *expect_messages;
1540 static HWND device_window, focus_window;
1541
1542 struct wndproc_thread_param
1543 {
1544     HWND dummy_window;
1545     HANDLE window_created;
1546     HANDLE test_finished;
1547     BOOL running_in_foreground;
1548 };
1549
1550 static LRESULT CALLBACK test_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1551 {
1552     if (filter_messages && filter_messages == hwnd)
1553     {
1554         if (message != WM_DISPLAYCHANGE && message != WM_IME_NOTIFY)
1555             todo_wine ok(0, "Received unexpected message %#x for window %p.\n", message, hwnd);
1556     }
1557
1558     if (expect_messages)
1559     {
1560         HWND w;
1561
1562         switch (expect_messages->window)
1563         {
1564             case DEVICE_WINDOW:
1565                 w = device_window;
1566                 break;
1567
1568             case FOCUS_WINDOW:
1569                 w = focus_window;
1570                 break;
1571
1572             default:
1573                 w = NULL;
1574                 break;
1575         };
1576
1577         if (hwnd == w && expect_messages->message == message) ++expect_messages;
1578     }
1579
1580     return DefWindowProcA(hwnd, message, wparam, lparam);
1581 }
1582
1583 static DWORD WINAPI wndproc_thread(void *param)
1584 {
1585     struct wndproc_thread_param *p = param;
1586     DWORD res;
1587     BOOL ret;
1588
1589     p->dummy_window = CreateWindowA("d3d8_test_wndproc_wc", "d3d8_test",
1590             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
1591     p->running_in_foreground = SetForegroundWindow(p->dummy_window);
1592
1593     ret = SetEvent(p->window_created);
1594     ok(ret, "SetEvent failed, last error %#x.\n", GetLastError());
1595
1596     for (;;)
1597     {
1598         MSG msg;
1599
1600         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
1601         res = WaitForSingleObject(p->test_finished, 100);
1602         if (res == WAIT_OBJECT_0) break;
1603         if (res != WAIT_TIMEOUT)
1604         {
1605             ok(0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
1606             break;
1607         }
1608     }
1609
1610     DestroyWindow(p->dummy_window);
1611
1612     return 0;
1613 }
1614
1615 static void test_wndproc(void)
1616 {
1617     struct wndproc_thread_param thread_params;
1618     IDirect3DDevice8 *device;
1619     WNDCLASSA wc = {0};
1620     IDirect3D8 *d3d8;
1621     HANDLE thread;
1622     LONG_PTR proc;
1623     ULONG ref;
1624     DWORD res, tid;
1625     HWND tmp;
1626
1627     static const struct message messages[] =
1628     {
1629         {WM_WINDOWPOSCHANGING,  FOCUS_WINDOW},
1630         {WM_ACTIVATE,           FOCUS_WINDOW},
1631         {WM_SETFOCUS,           FOCUS_WINDOW},
1632         {WM_WINDOWPOSCHANGING,  DEVICE_WINDOW},
1633         {WM_MOVE,               DEVICE_WINDOW},
1634         {WM_SIZE,               DEVICE_WINDOW},
1635         {0,                     0},
1636     };
1637
1638     if (!(d3d8 = pDirect3DCreate8(D3D_SDK_VERSION)))
1639     {
1640         skip("Failed to create IDirect3D8 object, skipping tests.\n");
1641         return;
1642     }
1643
1644     wc.lpfnWndProc = test_proc;
1645     wc.lpszClassName = "d3d8_test_wndproc_wc";
1646     ok(RegisterClassA(&wc), "Failed to register window class.\n");
1647
1648     thread_params.window_created = CreateEvent(NULL, FALSE, FALSE, NULL);
1649     ok(!!thread_params.window_created, "CreateEvent failed, last error %#x.\n", GetLastError());
1650     thread_params.test_finished = CreateEvent(NULL, FALSE, FALSE, NULL);
1651     ok(!!thread_params.test_finished, "CreateEvent failed, last error %#x.\n", GetLastError());
1652
1653     focus_window = CreateWindowA("d3d8_test_wndproc_wc", "d3d8_test",
1654             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, screen_width, screen_height, 0, 0, 0, 0);
1655     device_window = CreateWindowA("d3d8_test_wndproc_wc", "d3d8_test",
1656             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, screen_width, screen_height, 0, 0, 0, 0);
1657     thread = CreateThread(NULL, 0, wndproc_thread, &thread_params, 0, &tid);
1658     ok(!!thread, "Failed to create thread, last error %#x.\n", GetLastError());
1659
1660     res = WaitForSingleObject(thread_params.window_created, INFINITE);
1661     ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
1662
1663     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1664     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1665             (LONG_PTR)test_proc, proc);
1666     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1667     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1668             (LONG_PTR)test_proc, proc);
1669
1670     trace("device_window %p, focus_window %p, dummy_window %p.\n",
1671             device_window, focus_window, thread_params.dummy_window);
1672
1673     tmp = GetFocus();
1674     ok(tmp == device_window, "Expected focus %p, got %p.\n", device_window, tmp);
1675     if (thread_params.running_in_foreground)
1676     {
1677         tmp = GetForegroundWindow();
1678         ok(tmp == thread_params.dummy_window, "Expected foreground window %p, got %p.\n",
1679                 thread_params.dummy_window, tmp);
1680     }
1681     else
1682         skip("Not running in foreground, skip foreground window test\n");
1683
1684     flush_events();
1685
1686     expect_messages = messages;
1687
1688     device = create_device(d3d8, device_window, focus_window, FALSE);
1689     if (!device)
1690     {
1691         skip("Failed to create a D3D device, skipping tests.\n");
1692         goto done;
1693     }
1694
1695     ok(!expect_messages->message, "Expected message %#x for window %#x, but didn't receive it.\n",
1696             expect_messages->message, expect_messages->window);
1697     expect_messages = NULL;
1698
1699     if (0) /* Disabled until we can make this work in a reliable way on Wine. */
1700     {
1701         tmp = GetFocus();
1702         ok(tmp == focus_window, "Expected focus %p, got %p.\n", focus_window, tmp);
1703         tmp = GetForegroundWindow();
1704         ok(tmp == focus_window, "Expected foreground window %p, got %p.\n", focus_window, tmp);
1705     }
1706     SetForegroundWindow(focus_window);
1707     flush_events();
1708
1709     filter_messages = focus_window;
1710
1711     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1712     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1713             (LONG_PTR)test_proc, proc);
1714
1715     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1716     ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
1717             (LONG_PTR)test_proc, proc);
1718
1719     ref = IDirect3DDevice8_Release(device);
1720     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
1721
1722     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1723     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1724             (LONG_PTR)test_proc, proc);
1725
1726     device = create_device(d3d8, focus_window, focus_window, FALSE);
1727     if (!device)
1728     {
1729         skip("Failed to create a D3D device, skipping tests.\n");
1730         goto done;
1731     }
1732
1733     ref = IDirect3DDevice8_Release(device);
1734     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
1735
1736     device = create_device(d3d8, device_window, focus_window, FALSE);
1737     if (!device)
1738     {
1739         skip("Failed to create a D3D device, skipping tests.\n");
1740         goto done;
1741     }
1742
1743     proc = SetWindowLongPtrA(focus_window, GWLP_WNDPROC, (LONG_PTR)DefWindowProcA);
1744     ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
1745             (LONG_PTR)test_proc, proc);
1746
1747     ref = IDirect3DDevice8_Release(device);
1748     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
1749
1750     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1751     ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n",
1752             (LONG_PTR)DefWindowProcA, proc);
1753
1754 done:
1755     filter_messages = NULL;
1756     IDirect3D8_Release(d3d8);
1757
1758     SetEvent(thread_params.test_finished);
1759     WaitForSingleObject(thread, INFINITE);
1760     CloseHandle(thread_params.test_finished);
1761     CloseHandle(thread_params.window_created);
1762     CloseHandle(thread);
1763
1764     DestroyWindow(device_window);
1765     DestroyWindow(focus_window);
1766     UnregisterClassA("d3d8_test_wndproc_wc", GetModuleHandleA(NULL));
1767 }
1768
1769 static void test_wndproc_windowed(void)
1770 {
1771     struct wndproc_thread_param thread_params;
1772     IDirect3DDevice8 *device;
1773     WNDCLASSA wc = {0};
1774     IDirect3D8 *d3d8;
1775     HANDLE thread;
1776     LONG_PTR proc;
1777     HRESULT hr;
1778     ULONG ref;
1779     DWORD res, tid;
1780     HWND tmp;
1781
1782     if (!(d3d8 = pDirect3DCreate8(D3D_SDK_VERSION)))
1783     {
1784         skip("Failed to create IDirect3D8 object, skipping tests.\n");
1785         return;
1786     }
1787
1788     wc.lpfnWndProc = test_proc;
1789     wc.lpszClassName = "d3d8_test_wndproc_wc";
1790     ok(RegisterClassA(&wc), "Failed to register window class.\n");
1791
1792     thread_params.window_created = CreateEvent(NULL, FALSE, FALSE, NULL);
1793     ok(!!thread_params.window_created, "CreateEvent failed, last error %#x.\n", GetLastError());
1794     thread_params.test_finished = CreateEvent(NULL, FALSE, FALSE, NULL);
1795     ok(!!thread_params.test_finished, "CreateEvent failed, last error %#x.\n", GetLastError());
1796
1797     focus_window = CreateWindowA("d3d8_test_wndproc_wc", "d3d8_test",
1798             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
1799     device_window = CreateWindowA("d3d8_test_wndproc_wc", "d3d8_test",
1800             WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
1801     thread = CreateThread(NULL, 0, wndproc_thread, &thread_params, 0, &tid);
1802     ok(!!thread, "Failed to create thread, last error %#x.\n", GetLastError());
1803
1804     res = WaitForSingleObject(thread_params.window_created, INFINITE);
1805     ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
1806
1807     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1808     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1809             (LONG_PTR)test_proc, proc);
1810     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1811     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1812             (LONG_PTR)test_proc, proc);
1813
1814     trace("device_window %p, focus_window %p, dummy_window %p.\n",
1815             device_window, focus_window, thread_params.dummy_window);
1816
1817     tmp = GetFocus();
1818     ok(tmp == device_window, "Expected focus %p, got %p.\n", device_window, tmp);
1819     if (thread_params.running_in_foreground)
1820     {
1821         tmp = GetForegroundWindow();
1822         ok(tmp == thread_params.dummy_window, "Expected foreground window %p, got %p.\n",
1823                 thread_params.dummy_window, tmp);
1824     }
1825     else
1826         skip("Not running in foreground, skip foreground window test\n");
1827
1828     filter_messages = focus_window;
1829
1830     device = create_device(d3d8, device_window, focus_window, TRUE);
1831     if (!device)
1832     {
1833         skip("Failed to create a D3D device, skipping tests.\n");
1834         goto done;
1835     }
1836
1837     tmp = GetFocus();
1838     ok(tmp == device_window, "Expected focus %p, got %p.\n", device_window, tmp);
1839     tmp = GetForegroundWindow();
1840     ok(tmp == thread_params.dummy_window, "Expected foreground window %p, got %p.\n",
1841             thread_params.dummy_window, tmp);
1842
1843     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1844     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1845             (LONG_PTR)test_proc, proc);
1846
1847     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1848     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1849             (LONG_PTR)test_proc, proc);
1850
1851     filter_messages = NULL;
1852
1853     hr = reset_device(device, device_window, FALSE);
1854     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
1855
1856     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1857     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1858             (LONG_PTR)test_proc, proc);
1859
1860     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1861     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1862             (LONG_PTR)test_proc, proc);
1863
1864     hr = reset_device(device, device_window, TRUE);
1865     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
1866
1867     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1868     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1869             (LONG_PTR)test_proc, proc);
1870
1871     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1872     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1873             (LONG_PTR)test_proc, proc);
1874
1875     filter_messages = focus_window;
1876
1877     ref = IDirect3DDevice8_Release(device);
1878     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
1879
1880     filter_messages = device_window;
1881
1882     device = create_device(d3d8, focus_window, focus_window, TRUE);
1883     if (!device)
1884     {
1885         skip("Failed to create a D3D device, skipping tests.\n");
1886         goto done;
1887     }
1888
1889     filter_messages = NULL;
1890
1891     hr = reset_device(device, focus_window, FALSE);
1892     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
1893
1894     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1895     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1896             (LONG_PTR)test_proc, proc);
1897
1898     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1899     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1900             (LONG_PTR)test_proc, proc);
1901
1902     hr = reset_device(device, focus_window, TRUE);
1903     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
1904
1905     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1906     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1907             (LONG_PTR)test_proc, proc);
1908
1909     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1910     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1911             (LONG_PTR)test_proc, proc);
1912
1913     filter_messages = device_window;
1914
1915     ref = IDirect3DDevice8_Release(device);
1916     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
1917
1918     device = create_device(d3d8, device_window, focus_window, TRUE);
1919     if (!device)
1920     {
1921         skip("Failed to create a D3D device, skipping tests.\n");
1922         goto done;
1923     }
1924
1925     filter_messages = NULL;
1926
1927     hr = reset_device(device, device_window, FALSE);
1928     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
1929
1930     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1931     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1932             (LONG_PTR)test_proc, proc);
1933
1934     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1935     ok(proc != (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1936             (LONG_PTR)test_proc, proc);
1937
1938     hr = reset_device(device, device_window, TRUE);
1939     ok(SUCCEEDED(hr), "Failed to reset device, hr %#x.\n", hr);
1940
1941     proc = GetWindowLongPtrA(device_window, GWLP_WNDPROC);
1942     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1943             (LONG_PTR)test_proc, proc);
1944
1945     proc = GetWindowLongPtrA(focus_window, GWLP_WNDPROC);
1946     ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1947             (LONG_PTR)test_proc, proc);
1948
1949     filter_messages = device_window;
1950
1951     ref = IDirect3DDevice8_Release(device);
1952     ok(ref == 0, "The device was not properly freed: refcount %u.\n", ref);
1953
1954 done:
1955     filter_messages = NULL;
1956     IDirect3D8_Release(d3d8);
1957
1958     SetEvent(thread_params.test_finished);
1959     WaitForSingleObject(thread, INFINITE);
1960     CloseHandle(thread_params.test_finished);
1961     CloseHandle(thread_params.window_created);
1962     CloseHandle(thread);
1963
1964     DestroyWindow(device_window);
1965     DestroyWindow(focus_window);
1966     UnregisterClassA("d3d8_test_wndproc_wc", GetModuleHandleA(NULL));
1967 }
1968
1969 static inline void set_fpu_cw(WORD cw)
1970 {
1971 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1972     __asm__ volatile ("fnclex");
1973     __asm__ volatile ("fldcw %0" : : "m" (cw));
1974 #endif
1975 }
1976
1977 static inline WORD get_fpu_cw(void)
1978 {
1979     WORD cw = 0;
1980 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1981     __asm__ volatile ("fnstcw %0" : "=m" (cw));
1982 #endif
1983     return cw;
1984 }
1985
1986 static void test_fpu_setup(void)
1987 {
1988 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1989     D3DPRESENT_PARAMETERS present_parameters;
1990     IDirect3DDevice8 *device;
1991     D3DDISPLAYMODE d3ddm;
1992     HWND window = NULL;
1993     IDirect3D8 *d3d8;
1994     HRESULT hr;
1995     WORD cw;
1996
1997     d3d8 = pDirect3DCreate8(D3D_SDK_VERSION);
1998     ok(!!d3d8, "Failed to create a d3d8 object.\n");
1999     if (!d3d8) return;
2000
2001     window = CreateWindowA("static", "d3d8_test", WS_CAPTION, 0, 0, screen_width, screen_height, 0, 0, 0, 0);
2002     ok(!!window, "Failed to create a window.\n");
2003     if (!window) goto done;
2004
2005     hr = IDirect3D8_GetAdapterDisplayMode(d3d8, D3DADAPTER_DEFAULT, &d3ddm);
2006     ok(SUCCEEDED(hr), "GetAdapterDisplayMode failed, hr %#x.\n", hr);
2007
2008     memset(&present_parameters, 0, sizeof(present_parameters));
2009     present_parameters.Windowed = TRUE;
2010     present_parameters.hDeviceWindow = window;
2011     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
2012     present_parameters.BackBufferFormat = d3ddm.Format;
2013
2014     set_fpu_cw(0xf60);
2015     cw = get_fpu_cw();
2016     ok(cw == 0xf60, "cw is %#x, expected 0xf60.\n", cw);
2017
2018     hr = IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
2019             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
2020     if (FAILED(hr))
2021     {
2022         skip("Failed to create a device, hr %#x.\n", hr);
2023         set_fpu_cw(0x37f);
2024         goto done;
2025     }
2026
2027     cw = get_fpu_cw();
2028     ok(cw == 0x7f, "cw is %#x, expected 0x7f.\n", cw);
2029
2030     IDirect3DDevice8_Release(device);
2031
2032     cw = get_fpu_cw();
2033     ok(cw == 0x7f, "cw is %#x, expected 0x7f.\n", cw);
2034     set_fpu_cw(0xf60);
2035     cw = get_fpu_cw();
2036     ok(cw == 0xf60, "cw is %#x, expected 0xf60.\n", cw);
2037
2038     hr = IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
2039             D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE, &present_parameters, &device);
2040     ok(SUCCEEDED(hr), "CreateDevice failed, hr %#x.\n", hr);
2041
2042     cw = get_fpu_cw();
2043     ok(cw == 0xf60, "cw is %#x, expected 0xf60.\n", cw);
2044     set_fpu_cw(0x37f);
2045
2046     IDirect3DDevice8_Release(device);
2047
2048 done:
2049     if (window) DestroyWindow(window);
2050     if (d3d8) IDirect3D8_Release(d3d8);
2051 #endif
2052 }
2053
2054 static void test_ApplyStateBlock(void)
2055 {
2056     D3DPRESENT_PARAMETERS d3dpp;
2057     IDirect3DDevice8 *device = NULL;
2058     IDirect3D8 *d3d8;
2059     HWND hwnd;
2060     HRESULT hr;
2061     D3DDISPLAYMODE d3ddm;
2062     DWORD received, token;
2063
2064     d3d8 = pDirect3DCreate8( D3D_SDK_VERSION );
2065     ok(d3d8 != NULL, "Failed to create IDirect3D8 object\n");
2066     hwnd = CreateWindow( "static", "d3d8_test", WS_OVERLAPPEDWINDOW, 100, 100, 160, 160, NULL, NULL, NULL, NULL );
2067     ok(hwnd != NULL, "Failed to create window\n");
2068     if (!d3d8 || !hwnd) goto cleanup;
2069
2070     IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &d3ddm );
2071     ZeroMemory( &d3dpp, sizeof(d3dpp) );
2072     d3dpp.Windowed         = TRUE;
2073     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
2074     d3dpp.BackBufferWidth  = 800;
2075     d3dpp.BackBufferHeight  = 600;
2076     d3dpp.BackBufferFormat = d3ddm.Format;
2077     d3dpp.EnableAutoDepthStencil = TRUE;
2078     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
2079
2080     hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
2081                                   D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &d3dpp, &device );
2082     ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
2083        "IDirect3D8_CreateDevice failed with %#x\n", hr);
2084     if(!device)
2085     {
2086         skip("Failed to create a d3d device\n");
2087         goto cleanup;
2088     }
2089
2090     IDirect3DDevice8_BeginStateBlock(device);
2091     IDirect3DDevice8_SetRenderState(device, D3DRS_ZENABLE, TRUE);
2092     IDirect3DDevice8_EndStateBlock(device, &token);
2093     ok(token, "Received zero stateblock handle.\n");
2094     IDirect3DDevice8_SetRenderState(device, D3DRS_ZENABLE, FALSE);
2095
2096     hr = IDirect3DDevice8_GetRenderState(device, D3DRS_ZENABLE, &received);
2097     ok(hr == D3D_OK, "Expected D3D_OK, received %#x.\n", hr);
2098     ok(!received, "Expected = FALSE, received TRUE.\n");
2099
2100     IDirect3DDevice8_ApplyStateBlock(device, 0);
2101     ok(hr == D3D_OK, "Expected D3D_OK, received %#x.\n", hr);
2102     hr = IDirect3DDevice8_GetRenderState(device, D3DRS_ZENABLE, &received);
2103     ok(hr == D3D_OK, "Expected D3D_OK, received %#x.\n", hr);
2104     ok(!received, "Expected FALSE, received TRUE.\n");
2105
2106     IDirect3DDevice8_ApplyStateBlock(device, token);
2107     ok(hr == D3D_OK, "Expected D3D_OK, received %#x.\n", hr);
2108     hr = IDirect3DDevice8_GetRenderState(device, D3DRS_ZENABLE, &received);
2109     ok(hr == D3D_OK, "Expected D3D_OK, received %#x.\n", hr);
2110     ok(received, "Expected TRUE, received FALSE.\n");
2111
2112     IDirect3DDevice8_DeleteStateBlock(device, token);
2113     IDirect3DDevice8_Release(device);
2114 cleanup:
2115     if (d3d8) IDirect3D8_Release(d3d8);
2116 }
2117
2118 START_TEST(device)
2119 {
2120     HMODULE d3d8_handle = LoadLibraryA( "d3d8.dll" );
2121     if (!d3d8_handle)
2122     {
2123         skip("Could not load d3d8.dll\n");
2124         return;
2125     }
2126
2127     pDirect3DCreate8 = (void *)GetProcAddress( d3d8_handle, "Direct3DCreate8" );
2128     ok(pDirect3DCreate8 != NULL, "Failed to get address of Direct3DCreate8\n");
2129     if (pDirect3DCreate8)
2130     {
2131         IDirect3D8 *d3d8;
2132         d3d8 = pDirect3DCreate8( D3D_SDK_VERSION );
2133         if(!d3d8)
2134         {
2135             skip("could not create D3D8\n");
2136             return;
2137         }
2138         IDirect3D8_Release(d3d8);
2139
2140         screen_width = GetSystemMetrics(SM_CXSCREEN);
2141         screen_height = GetSystemMetrics(SM_CYSCREEN);
2142
2143         test_fpu_setup();
2144         test_display_modes();
2145         test_shader_versions();
2146         test_swapchain();
2147         test_refcount();
2148         test_mipmap_levels();
2149         test_cursor();
2150         test_states();
2151         test_scene();
2152         test_shader();
2153         test_limits();
2154         test_lights();
2155         test_ApplyStateBlock();
2156         test_render_zero_triangles();
2157         test_depth_stencil_reset();
2158         test_wndproc();
2159         test_wndproc_windowed();
2160     }
2161 }