[PATCH v2 1/3] d3dcompiler/tests: Rewrite to use a separate d3d9 device for each test.

[Zebediah Figura]

This brings the d3dcompiler tests more in line with existing d3d9 tests, and
allows potentially running the tests in parallel.

Signed-off-by: Zebediah Figura 
---
 dlls/d3dcompiler_43/tests/hlsl.c | 801 +++++++++++++++----------------
 1 file changed, 384 insertions(+), 417 deletions(-)

diff --git a/dlls/d3dcompiler_43/tests/hlsl.c b/dlls/d3dcompiler_43/tests/hlsl.c
index 868693838cc..9114ec98e1d 100644
--- a/dlls/d3dcompiler_43/tests/hlsl.c
+++ b/dlls/d3dcompiler_43/tests/hlsl.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2010 Travis Athougies
+ * Copyright (C) 2020 Zebediah Figura
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,290 +26,265 @@
 static pD3DCompile ppD3DCompile;

static HRESULT (WINAPI *pD3DXGetShaderConstantTable)(const DWORD *byte_code, ID3DXConstantTable **constant_table);
-static D3DMATRIX *(WINAPI *pD3DXMatrixOrthoLH)(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf);

-struct vertex
+struct vec2
 {
-    float x, y, z;
-    float tx, ty;
+    float x, y;
 };

-/* Tells compute_shader_probe* which pixels should be what colors */
-struct hlsl_probe_info
+struct vec4
 {
-    unsigned int x, y;
-    /* The expected values in this region */
-    D3DXCOLOR c;
-    /* The max error for any value */
-    float epsilon;
-    /* An error message to print if this test fails */
-    const char *message;
+    float x, y, z, w;
 };

-static HWND create_window(void)
+#define compile_shader(a, b) compile_shader_(__LINE__, a, b)
+static ID3D10Blob *compile_shader_(unsigned int line, const char *source, const char *target)
 {
-    WNDCLASSA wc = {0};
-    wc.lpfnWndProc = DefWindowProcA;
-    wc.lpszClassName = "d3d9_test_wc";
-    RegisterClassA(&wc);
+    ID3D10Blob *blob = NULL, *errors = NULL;
+    HRESULT hr;

-    return CreateWindowA("d3d9_test_wc", "d3d9_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    hr = ppD3DCompile(source, strlen(source), NULL, NULL, NULL, "main", target, 0, 0, &blob, &errors);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to compile shader, hr %#x.\n", hr);
+    if (errors)
+    {
+        if (winetest_debug > 1)
+            trace_(__FILE__, line)("%s\n", (char *)ID3D10Blob_GetBufferPointer(errors));
+        ID3D10Blob_Release(errors);
+    }
+    return blob;
 }

-static IDirect3DDevice9 *init_d3d9(IDirect3DVertexDeclaration9 **vdeclaration,
-        IDirect3DVertexBuffer9 **quad_geometry, IDirect3DVertexShader9 **vshader_passthru)
+static IDirect3DDevice9 *create_d3d9_device(HWND window)
 {
-    static const struct vertex quad_vertices[4] =
+    D3DPRESENT_PARAMETERS present_parameters =
     {
-        {-1.0f, -1.0f, 0.0f, 0.0f, 1.0f},
-        {-1.0f,  1.0f, 0.0f, 0.0f, 0.0f},
-        { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f},
-        { 1.0f,  1.0f, 0.0f, 1.0f, 0.0f}
+        .Windowed = TRUE,
+        .hDeviceWindow = window,
+        .SwapEffect = D3DSWAPEFFECT_DISCARD,
+        .BackBufferWidth = 640,
+        .BackBufferHeight = 480,
+        .BackBufferFormat = D3DFMT_A8R8G8B8,
     };
-
-    static const D3DVERTEXELEMENT9 vdeclelements[] =
-    {
-        {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
-        {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
-        D3DDECL_END()
-    };
-
-    static const char *vshader_passthru_hlsl =
-        "float4 vshader(float4 pos: POSITION, inout float2 texcoord: TEXCOORD0): POSITION\n"
-        "{\n"
-        "   return pos;\n"
-        "}";
-
-    IDirect3D9 *d3d9_ptr;
-    IDirect3DDevice9 *device_ptr = NULL;
-    D3DPRESENT_PARAMETERS present_parameters;
-
-    void *temp_geometry_vertices;
-
-    ID3D10Blob *compiled = NULL;
-    ID3D10Blob *errors = NULL;
-
+    IDirect3DDevice9 *device;
+    IDirect3DSurface9 *rt;
+    IDirect3D9 *d3d;
+    D3DCAPS9 caps;
     HRESULT hr;

-    d3d9_ptr = Direct3DCreate9(D3D_SDK_VERSION);
-    if (!d3d9_ptr)
+    d3d = Direct3DCreate9(D3D_SDK_VERSION);
+    ok(!!d3d, "Failed to create a D3D object.\n");
+
+    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
+            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
+    IDirect3D9_Release(d3d);
+    if (FAILED(hr))
     {
-        skip("could not create D3D9\n");
+        skip("Failed to create a 3D device, hr %#x.\n", hr);
         return NULL;
     }

-    hr = IDirect3D9_CheckDeviceFormat(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
-            0, D3DRTYPE_SURFACE, D3DFMT_A32B32G32R32F);
-    if (FAILED(hr))
+    hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
+    ok(hr == D3D_OK, "Failed to get device caps, hr %#x.\n", hr);
+    if (caps.PixelShaderVersion < D3DPS_VERSION(2, 0) || caps.VertexShaderVersion < D3DVS_VERSION(2, 0))
     {
-        skip("A32B32G32R32F format not available on this device\n");
-        IDirect3D9_Release(d3d9_ptr);
+        skip("No shader model 2 support.\n");
+        IDirect3DDevice9_Release(device);
         return NULL;
     }

-    ZeroMemory(&present_parameters, sizeof(present_parameters));
-    present_parameters.Windowed = TRUE;
-    present_parameters.hDeviceWindow = create_window();
-    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
-
-    hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL,
-            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
-    IDirect3D9_Release(d3d9_ptr);
-    if (FAILED(hr))
+    if (FAILED(hr = IDirect3DDevice9_CreateRenderTarget(device, 640, 480, D3DFMT_A32B32G32R32F,
+            D3DMULTISAMPLE_NONE, 0, FALSE, &rt, NULL)))
     {
-        skip("could not create Direct3D9 device\n");
+        skip("Failed to create an A32B32G32R32F surface, hr %#x.\n", hr);
+        IDirect3DDevice9_Release(device);
         return NULL;
     }
+    ok(hr == D3D_OK, "Failed to create render target, hr %#x.\n", hr);
+    hr = IDirect3DDevice9_SetRenderTarget(device, 0, rt);
+    ok(hr == D3D_OK, "Failed to set render target, hr %#x.\n", hr);
+    IDirect3DSurface9_Release(rt);

-    /* Create the quad geometry */
-    hr = IDirect3DDevice9_CreateVertexBuffer(device_ptr, 4 * sizeof(struct vertex),
-            D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, quad_geometry, NULL);
-    ok(SUCCEEDED(hr),
-            "Could not create vertex buffer, IDirect3DDevice9_CreateVertexBuffer returned: %08x\n", hr);
-
-    hr = IDirect3DVertexBuffer9_Lock(*quad_geometry, 0, sizeof(quad_vertices), &temp_geometry_vertices, 0);
-    ok(SUCCEEDED(hr), "IDirect3DVertexBuffer9_Lock returned: %08x\n", hr);
-    memcpy(temp_geometry_vertices, quad_vertices, sizeof(quad_vertices));
-    IDirect3DVertexBuffer9_Unlock(*quad_geometry);
+    return device;
+}

-    hr = IDirect3DDevice9_CreateVertexDeclaration(device_ptr, vdeclelements, vdeclaration);
-    ok(SUCCEEDED(hr), "Could not create vertex declaration: "
-            "IDirect3DDevice9_CreateVertexDeclaration returned: %08x\n", hr);
+#define draw_quad(device, ps_code) draw_quad_(__LINE__, device, ps_code)
+static void draw_quad_(unsigned int line, IDirect3DDevice9 *device, ID3D10Blob *ps_code)
+{
+    IDirect3DVertexDeclaration9 *vertex_declaration;
+    IDirect3DVertexShader9 *vs;
+    IDirect3DPixelShader9 *ps;
+    ID3D10Blob *vs_code;
+    HRESULT hr;

-    hr = IDirect3DDevice9_SetVertexDeclaration(device_ptr, *vdeclaration);
-    ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned: %08x\n", hr);
+    static const D3DVERTEXELEMENT9 decl_elements[] =
+    {
+        {0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
+        {0, 8, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
+        D3DDECL_END()
+    };

-    /* Create a simple vertex shader to just pass through the values */
-    hr = ppD3DCompile(vshader_passthru_hlsl, strlen(vshader_passthru_hlsl), NULL,
-            NULL, NULL, "vshader", "vs_1_1", 0, 0, &compiled, &errors);
-    if (FAILED(hr))
+    static const struct
     {
-        skip("not compiling vertex shader due to lacking wine HLSL support!\n");
-        if (errors)
-            ID3D10Blob_Release(errors);
-        return NULL;
+        struct vec2 position;
+        struct vec2 t0;
     }
+    quad[] =
+    {
+        {{-1.0f, -1.0f}, {0.0f, 1.0f}},
+        {{-1.0f,  1.0f}, {0.0f, 0.0f}},
+        {{ 1.0f, -1.0f}, {1.0f, 1.0f}},
+        {{ 1.0f,  1.0f}, {1.0f, 0.0f}},
+    };

-    hr = IDirect3DDevice9_CreateVertexShader(device_ptr, ID3D10Blob_GetBufferPointer(compiled),
-            vshader_passthru);
-    ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader returned: %08x\n", hr);
-    ID3D10Blob_Release(compiled);
+    static const char vs_source[] =
+        "float4 main(float4 pos : POSITION, inout float2 texcoord : TEXCOORD0) : POSITION\n"
+        "{\n"
+        "   return pos;\n"
+        "}";

-    return device_ptr;
-}
+    hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to create vertex declaration, hr %#x.\n", hr);

-/* Convenience functions */
-static void set_float4_d3d9(IDirect3DDevice9 *device, ID3DXConstantTable *constants, const char *name,
-        float x, float y, float z, float w)
-{
-    D3DXVECTOR4 vector;
-    vector.x = x;
-    vector.y = y;
-    vector.z = z;
-    vector.w = w;
-    ID3DXConstantTable_SetVector(constants, device, name, &vector);
-}
+    hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to set vertex declaration, hr %#x.\n", hr);

-/* Compile our pixel shader and get back the compiled version and a constant table */
-static IDirect3DPixelShader9 *compile_pixel_shader9(IDirect3DDevice9 *device, const char *shader,
-        const char *profile, ID3DXConstantTable **constants)
-{
-    ID3D10Blob *compiled = NULL;
-    ID3D10Blob *errors = NULL;
-    IDirect3DPixelShader9 *pshader;
-    HRESULT hr;
+    vs_code = compile_shader(vs_source, "vs_2_0");
+
+    hr = IDirect3DDevice9_CreateVertexShader(device, ID3D10Blob_GetBufferPointer(vs_code), &vs);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to create vertex shader, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice9_SetVertexShader(device, vs);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to set vertex shader, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice9_CreatePixelShader(device, ID3D10Blob_GetBufferPointer(ps_code), &ps);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to create pixel shader, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice9_SetPixelShader(device, ps);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to set pixel shader, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice9_BeginScene(device);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to draw, hr %#x.\n", hr);

-    hr = ppD3DCompile(shader, strlen(shader), NULL, NULL,
-            NULL, "test", profile, /* test is the name of the entry point of our shader */
-            0, 0, &compiled, &errors);
-    ok(hr == D3D_OK, "Pixel shader %s compilation failed: %s\n", shader,
-            errors ? (char *)ID3D10Blob_GetBufferPointer(errors) : "");
-    if (FAILED(hr)) return NULL;
+    hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to draw, hr %#x.\n", hr);

-    hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(compiled), constants);
-    ok(hr == D3D_OK, "Could not get constant table from compiled pixel shader\n");
+    hr = IDirect3DDevice9_EndScene(device);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to draw, hr %#x.\n", hr);

-    hr = IDirect3DDevice9_CreatePixelShader(device, ID3D10Blob_GetBufferPointer(compiled), &pshader);
-    ok(SUCCEEDED(hr), "IDirect3DDevice9_CreatePixelShader returned: %08x\n", hr);
-    ID3D10Blob_Release(compiled);
-    return pshader;
+    IDirect3DVertexShader9_Release(vs);
+    IDirect3DPixelShader9_Release(ps);
+    ID3D10Blob_Release(vs_code);
 }

-/* Draw a full screen quad */
-static void draw_quad_with_shader9(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry)
+static struct vec4 get_readback_vec4_d3d9(IDirect3DDevice9 *device, unsigned int x, unsigned int y)
 {
+    IDirect3DSurface9 *surface = NULL, *target = NULL;
+    RECT rect = {x, y, x + 1, y + 1};
+    D3DLOCKED_RECT locked_rect;
+    D3DSURFACE_DESC desc;
+    struct vec4 ret;
     HRESULT hr;
-    D3DXMATRIX projection_matrix;

-    pD3DXMatrixOrthoLH(&projection_matrix, 2.0f, 2.0f, 0.0f, 1.0f);
-    IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &projection_matrix);
+    hr = IDirect3DDevice9Ex_GetRenderTarget(device, 0, &target);
+    ok(hr == D3D_OK, "Failed to get render target, hr %#x.\n", hr);

-    hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
-    ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned: %08x\n", hr);
+    hr = IDirect3DSurface9_GetDesc(target, &desc);
+    ok(hr == D3D_OK, "Failed to get surface desc, hr %#x.\n", hr);
+    hr = IDirect3DDevice9Ex_CreateOffscreenPlainSurface(device, desc.Width, desc.Height,
+            desc.Format, D3DPOOL_SYSTEMMEM, &surface, NULL);
+    ok(hr == D3D_OK, "Failed to create surface, hr %#x.\n", hr);

-    hr = IDirect3DDevice9_BeginScene(device);
-    ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned: %08x\n", hr);
+    hr = IDirect3DDevice9Ex_GetRenderTargetData(device, target, surface);
+    ok(hr == D3D_OK, "Failed to get render target data, hr %#x.\n", hr);

-    hr = IDirect3DDevice9_SetStreamSource(device, 0, quad_geometry, 0, sizeof(struct vertex));
-    ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource returned: %08x\n", hr);
-    hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
-    ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive returned: %08x\n", hr);
+    hr = IDirect3DSurface9_LockRect(surface, &locked_rect, &rect, D3DLOCK_READONLY);
+    ok(hr == D3D_OK, "Failed to lock surface, hr %#x.\n", hr);

-    hr = IDirect3DDevice9_EndScene(device);
-    ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned: %08x\n", hr);
+    ret = ((struct vec4 *)locked_rect.pBits)[0];
+
+    IDirect3DSurface9_UnlockRect(surface);
+
+    IDirect3DSurface9_Release(target);
+    IDirect3DSurface9_Release(surface);
+    return ret;
 }

-static void setup_device9(IDirect3DDevice9 *device, IDirect3DSurface9 **render_target,
-        IDirect3DSurface9 **readback, D3DFORMAT format, unsigned int width, unsigned int height,
-        IDirect3DVertexShader9 *vshader, IDirect3DPixelShader9 *pshader)
+#define set_float_d3d9(a, b, c, d) set_float_d3d9_(__LINE__, a, b, c, d)
+static void set_float_d3d9_(unsigned int line, IDirect3DDevice9 *device, ID3D10Blob *blob, const char *name, float f)
 {
+    ID3DXConstantTable *constants;
     HRESULT hr;
-    hr = IDirect3DDevice9_CreateRenderTarget(device, width, height, format,
-            D3DMULTISAMPLE_NONE, 0, FALSE, render_target, NULL);
-    ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget returned: %08x\n", hr);
-
-    /* The Direct3D 9 docs state that we cannot lock a render target surface,
-       instead we must copy the render target onto this surface to lock it */
-    hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, width, height, format,
-            D3DPOOL_SYSTEMMEM, readback, NULL);
-    ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned: %08x\n", hr);
-
-    hr = IDirect3DDevice9_SetRenderTarget(device, 0, *render_target);
-    ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget returned: %08x\n", hr);
-
-    hr = IDirect3DDevice9_SetVertexShader(device, vshader);
-    ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned: %08x\n", hr);
-    hr = IDirect3DDevice9_SetPixelShader(device, pshader);
-    ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned: %08x\n", hr);
+
+    hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(blob), &constants);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to get constant table, hr %#x.\n", hr);
+
+    hr = ID3DXConstantTable_SetFloat(constants, device, name, f);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to set constant, hr %#x.\n", hr);
+
+    ID3DXConstantTable_Release(constants);
 }

-static BOOL colors_match(D3DXCOLOR a, D3DXCOLOR b, float epsilon)
+#define set_float4_d3d9(a, b, c, d, e, f, g) set_float4_d3d9_(__LINE__, a, b, c, d, e, f, g)
+static void set_float4_d3d9_(unsigned int line, IDirect3DDevice9 *device, ID3D10Blob *blob,
+        const char *name, float x, float y, float z, float w)
 {
-  return (fabs(a.r - b.r) < epsilon && fabs(a.g - b.g) < epsilon && fabs(a.b - b.b) < epsilon &&
-          fabs(a.a - b.a) < epsilon);
+    ID3DXConstantTable *constants;
+    D3DXVECTOR4 v = {x, y, z, w};
+    HRESULT hr;
+
+    hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(blob), &constants);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to get constant table, hr %#x.\n", hr);
+
+    hr = ID3DXConstantTable_SetVector(constants, device, name, &v);
+    ok_(__FILE__, line)(hr == D3D_OK, "Failed to set constant, hr %#x.\n", hr);
+
+    ID3DXConstantTable_Release(constants);
 }

-/* Compute a shader on a width by height buffer and probes certain locations
-   to see if they are as expected. */
-static void compute_shader_probe9(IDirect3DDevice9 *device, IDirect3DVertexShader9 *vshader,
-        IDirect3DPixelShader9 *pshader, IDirect3DVertexBuffer9 *quad_geometry,
-        const struct hlsl_probe_info *probes, unsigned int count,
-        unsigned int width, unsigned int height, unsigned int line_number)
+static BOOL compare_float(float f, float g, unsigned int ulps)
 {
-    IDirect3DSurface9 *render_target;
-    IDirect3DSurface9 *readback;
+    int x = *(int *)&f;
+    int y = *(int *)&g;

-    HRESULT hr;
-    D3DLOCKED_RECT lr;
-    D3DXCOLOR *pbits_data;
-    unsigned int i;
+    if (x < 0)
+        x = INT_MIN - x;
+    if (y < 0)
+        y = INT_MIN - y;

-    setup_device9(device, &render_target, &readback, D3DFMT_A32B32G32R32F,
-            width, height, vshader, pshader);
-
-    /* Draw the quad with the shader and read back the data */
-    draw_quad_with_shader9(device, quad_geometry);
-    IDirect3DDevice9_GetRenderTargetData(device, render_target, readback);
-    hr = IDirect3DSurface9_LockRect(readback, &lr, NULL, D3DLOCK_READONLY);
-    ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned: %08x\n", hr);
-    pbits_data = lr.pBits;
-
-    /* Now go through the probes and check each one */
-    for (i = 0; i < count; i++, probes++) {
-        int index = probes->x + (probes->y * lr.Pitch / sizeof(D3DXCOLOR));
-        ok(colors_match(probes->c, pbits_data[index], probes->epsilon),
-                "Line %d: At (%d, %d): %s: Expected (%.04f,%.04f,%.04f, %.04f), got "
-                "(%.04f,%.04f,%.04f,%.04f)\n", line_number, probes->x, probes->y, probes->message,
-                probes->c.r, probes->c.g, probes->c.b, probes->c.a, pbits_data[index].r,
-                pbits_data[index].g, pbits_data[index].b, pbits_data[index].a);
-    }
+    if (abs(x - y) > ulps)
+        return FALSE;

-    hr = IDirect3DSurface9_UnlockRect(readback);
-    ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned: %08x\n", hr);
+    return TRUE;
+}
+
+static BOOL compare_vec4(const struct vec4 *vec, float x, float y, float z, float w, unsigned int ulps)
+{
+    return compare_float(vec->x, x, ulps)
+            && compare_float(vec->y, y, ulps)
+            && compare_float(vec->z, z, ulps)
+            && compare_float(vec->w, w, ulps);
+}

-    /* We now present the scene. This is mostly for debugging purposes, since GetRenderTargetData
-       also waits for drawing commands to complete. The reason this call is here and not in a
-       draw function is because the contents of the render target surface are invalidated after
-       this call. */
-    hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
-    ok(hr == D3D_OK, "IDirect3DDevice9_Present returned: %08x\n", hr);
+static HWND create_window(void)
+{
+    WNDCLASSA wc = {0};
+    wc.lpfnWndProc = DefWindowProcA;
+    wc.lpszClassName = "d3d9_test_wc";
+    RegisterClassA(&wc);

-    IDirect3DSurface9_Release(render_target);
-    IDirect3DSurface9_Release(readback);
+    return CreateWindowA("d3d9_test_wc", "d3d9_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
 }

-/* Now the actual test functions */
-static void test_swizzle(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
-        IDirect3DVertexShader9 *vshader_passthru)
+static void test_swizzle(void)
 {
-    static const struct hlsl_probe_info probes[] =
-    {
-       {0, 0, {0.0101f, 0.0303f, 0.0202f, 0.0404f}, 0.0001f, "swizzle_test"}
-    };
+    IDirect3DDevice9 *device;
+    ID3D10Blob *ps_code;
+    struct vec4 v;
+    HWND window;

-    static const char *swizzle_test_shader =
+    static const char ps_source[] =
         "uniform float4 color;\n"
-        "float4 test(): COLOR\n"
+        "float4 main() : COLOR\n"
         "{\n"
         "    float4 ret = color;\n"
         "    ret.gb = ret.ra;\n"
@@ -316,36 +292,40 @@ static void test_swizzle(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_
         "    return ret;\n"
         "}";

-    ID3DXConstantTable *constants;
-    IDirect3DPixelShader9 *pshader;
+    window = create_window();
+    ok(!!window, "Failed to create a window.\n");

-    pshader = compile_pixel_shader9(device, swizzle_test_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    if (!(device = create_d3d9_device(window)))
     {
-        set_float4_d3d9(device, constants, "color", 0.0303f, 0.0f, 0.0f, 0.0202f);
+        DestroyWindow(window);
+        return;
+    }
+
+    todo_wine ps_code = compile_shader(ps_source, "ps_2_0");
+    if (ps_code)
+    {
+        set_float4_d3d9(device, ps_code, "color", 0.0303f, 0.0f, 0.0f, 0.0202f);
+        draw_quad(device, ps_code);

-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry,
-                probes, ARRAY_SIZE(probes), 1, 1, __LINE__);
+        v = get_readback_vec4_d3d9(device, 0, 0);
+        ok(compare_vec4(&v, 0.0101f, 0.0303f, 0.0202f, 0.0404f, 0),
+                "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);

-        ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+        ID3D10Blob_Release(ps_code);
     }
+    IDirect3DDevice9_Release(device);
+    DestroyWindow(window);
 }

-static void test_math(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
-        IDirect3DVertexShader9 *vshader_passthru)
+static void test_math(void)
 {
-    /* Tests order of operations */
-    static const float u = 2.5f, v = 0.3f, w = 0.2f, x = 0.7f, y = 0.1f, z = 1.5f;
-
-    static const struct hlsl_probe_info probes[] =
-    {
-        {0, 0, {-12.4300f, 9.8333f, 1.6000f, 34.9999f}, 0.0001f,
-                "order of operations test"}
-    };
+    IDirect3DDevice9 *device;
+    ID3D10Blob *ps_code;
+    struct vec4 v;
+    HWND window;

-    static const char *order_of_operations_shader =
-        "float4 test(uniform float u, uniform float v, uniform float w, uniform float x,\n"
+    static const char ps_source[] =
+        "float4 main(uniform float u, uniform float v, uniform float w, uniform float x,\n"
         "            uniform float y, uniform float z): COLOR\n"
         "{\n"
         "    return float4(x * y - z / w + --u / -v,\n"
@@ -354,101 +334,127 @@ static void test_math(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geo
         "            x / y / w);\n"
         "}";

-    ID3DXConstantTable *constants;
-    IDirect3DPixelShader9 *pshader;
+    window = create_window();
+    ok(!!window, "Failed to create a window.\n");

-    pshader = compile_pixel_shader9(device, order_of_operations_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    if (!(device = create_d3d9_device(window)))
     {
-        ID3DXConstantTable_SetFloat(constants, device, "$u", u);
-        ID3DXConstantTable_SetFloat(constants, device, "$v", v);
-        ID3DXConstantTable_SetFloat(constants, device, "$w", w);
-        ID3DXConstantTable_SetFloat(constants, device, "$x", x);
-        ID3DXConstantTable_SetFloat(constants, device, "$y", y);
-        ID3DXConstantTable_SetFloat(constants, device, "$z", z);
-
-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry,
-                probes, ARRAY_SIZE(probes), 1, 1, __LINE__);
+        DestroyWindow(window);
+        return;
+    }

-        ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+    todo_wine ps_code = compile_shader(ps_source, "ps_2_0");
+    if (ps_code)
+    {
+        set_float_d3d9(device, ps_code, "$u", 2.5f);
+        set_float_d3d9(device, ps_code, "$v", 0.3f);
+        set_float_d3d9(device, ps_code, "$w", 0.2f);
+        set_float_d3d9(device, ps_code, "$x", 0.7f);
+        set_float_d3d9(device, ps_code, "$y", 0.1f);
+        set_float_d3d9(device, ps_code, "$z", 1.5f);
+        draw_quad(device, ps_code);
+
+        v = get_readback_vec4_d3d9(device, 0, 0);
+        ok(compare_vec4(&v, -12.43f, 9.833333f, 1.6f, 35.0f, 1),
+                "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+
+        ID3D10Blob_Release(ps_code);
     }
+    IDirect3DDevice9_Release(device);
+    DestroyWindow(window);
 }

-static void test_conditionals(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
-        IDirect3DVertexShader9 *vshader_passthru)
+static void test_conditionals(void)
 {
-    static const struct hlsl_probe_info if_greater_probes[] =
-    {
-        { 0, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
-        { 5, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
-        {10, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
-        {15, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
-        {25, 0, {0.1f, 0.2f, 0.3f, 0.4f}, 0.0001f, "if greater test"},
-        {30, 0, {0.1f, 0.2f, 0.3f, 0.4f}, 0.0001f, "if greater test"}
-    };
+    IDirect3DDevice9 *device;
+    ID3D10Blob *ps_code;
+    unsigned int i;
+    struct vec4 v;
+    HWND window;

-    static const char *if_greater_shader =
-        "float4 test(float2 pos: TEXCOORD0): COLOR\n"
+    static const char ps_if_source[] =
+        "float4 main(float2 pos : TEXCOORD0) : COLOR\n"
         "{\n"
-        "    if((pos.x * 32.0) > 20.0)\n"
+        "    if((pos.x * 640.0) > 200.0)\n"
         "        return float4(0.1, 0.2, 0.3, 0.4);\n"
         "    else\n"
         "        return float4(0.9, 0.8, 0.7, 0.6);\n"
         "}";

-    static const struct hlsl_probe_info ternary_operator_probes[] =
-    {
-        {0, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
-        {1, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
-        {2, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
-        {3, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
-        {4, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"},
-        {5, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"},
-        {6, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"},
-        {7, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"}
-    };
-
-    static const char *ternary_operator_shader =
-        "float4 test(float2 pos: TEXCOORD0): COLOR\n"
+    static const char ps_ternary_source[] =
+        "float4 main(float2 pos : TEXCOORD0) : COLOR\n"
         "{\n"
         "    return (pos.x < 0.5?float4(0.5, 0.25, 0.5, 0.75):float4(0.6, 0.8, 0.1, 0.2));\n"
         "}";

-    ID3DXConstantTable *constants;
-    IDirect3DPixelShader9 *pshader;
+    window = create_window();
+    ok(!!window, "Failed to create a window.\n");
+
+    if (!(device = create_d3d9_device(window)))
+    {
+        DestroyWindow(window);
+        return;
+    }

-    pshader = compile_pixel_shader9(device, if_greater_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    todo_wine ps_code = compile_shader(ps_if_source, "ps_2_0");
+    if (ps_code)
     {
-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, if_greater_probes,
-                ARRAY_SIZE(if_greater_probes), 32, 1, __LINE__);
+        draw_quad(device, ps_code);

-        ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+        for (i = 0; i < 200; i += 40)
+        {
+            v = get_readback_vec4_d3d9(device, i, 0);
+            ok(compare_vec4(&v, 0.9f, 0.8f, 0.7f, 0.6f, 0),
+                    "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+        }
+
+        for (i = 240; i < 640; i += 40)
+        {
+            v = get_readback_vec4_d3d9(device, i, 0);
+            ok(compare_vec4(&v, 0.1f, 0.2f, 0.3f, 0.4f, 0),
+                    "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+        }
+
+        ID3D10Blob_Release(ps_code);
     }

-    pshader = compile_pixel_shader9(device, ternary_operator_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    todo_wine ps_code = compile_shader(ps_ternary_source, "ps_2_0");
+    if (ps_code)
     {
-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, ternary_operator_probes,
-                ARRAY_SIZE(ternary_operator_probes), 8, 1, __LINE__);
+        draw_quad(device, ps_code);

-        ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+        for (i = 0; i < 320; i += 40)
+        {
+            v = get_readback_vec4_d3d9(device, i, 0);
+            ok(compare_vec4(&v, 0.5f, 0.25f, 0.5f, 0.75f, 0),
+                    "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+        }
+
+        for (i = 360; i < 640; i += 40)
+        {
+            v = get_readback_vec4_d3d9(device, i, 0);
+            ok(compare_vec4(&v, 0.6f, 0.8f, 0.1f, 0.2f, 0),
+                    "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+        }
+
+        ID3D10Blob_Release(ps_code);
     }
+
+    IDirect3DDevice9_Release(device);
+    DestroyWindow(window);
 }

-static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
-        IDirect3DVertexShader9 *vshader_passthru)
+static void test_float_vectors(void)
 {
-    static const struct hlsl_probe_info vec4_indexing_test1_probes[] =
-    {
-        {0, 0, {0.020f, 0.245f, 0.351f, 1.000f}, 0.0001f, "vec4 indexing test 1"}
-    };
+    ID3DXConstantTable *constants;
+    IDirect3DDevice9 *device;
+    ID3D10Blob *ps_code;
+    struct vec4 v;
+    HWND window;
+    HRESULT hr;

-    static const char *vec4_indexing_test1_shader =
-        "float4 test(): COLOR\n"
+    static const char ps_indexing_source[] =
+        "float4 main() : COLOR\n"
         "{\n"
         "    float4 color;\n"
         "    color[0] = 0.020;\n"
@@ -458,15 +464,10 @@ static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9
         "    return color;\n"
         "}";

-    static const struct hlsl_probe_info vec4_indexing_test2_probes[] =
-    {
-        {0, 0, {0.5f, 0.3f, 0.8f, 0.2f}, 0.0001f, "vec4 indexing test 2"}
-    };
-
-    /* We have this uniform i here so the compiler can't optimize */
-    static const char *vec4_indexing_test2_shader =
+    /* A uniform index is used so that the compiler can't optimize. */
+    static const char ps_uniform_indexing_source[] =
         "uniform int i;\n"
-        "float4 test(): COLOR\n"
+        "float4 main() : COLOR\n"
         "{\n"
         "    float4 color = float4(0.5, 0.4, 0.3, 0.2);\n"
         "    color.g = color[i];\n"
@@ -474,73 +475,58 @@ static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9
         "    return color;\n"
         "}";

-    ID3DXConstantTable *constants;
-    IDirect3DPixelShader9 *pshader;
+    window = create_window();
+    ok(!!window, "Failed to create a window.\n");

-    pshader = compile_pixel_shader9(device, vec4_indexing_test1_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    if (!(device = create_d3d9_device(window)))
     {
-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, vec4_indexing_test1_probes,
-                ARRAY_SIZE(vec4_indexing_test1_probes), 1, 1, __LINE__);
-
-        ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+        DestroyWindow(window);
+        return;
     }

-    pshader = compile_pixel_shader9(device, vec4_indexing_test2_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    todo_wine ps_code = compile_shader(ps_indexing_source, "ps_2_0");
+    if (ps_code)
     {
-        ID3DXConstantTable_SetInt(constants, device, "i", 2);
+        draw_quad(device, ps_code);
+
+        v = get_readback_vec4_d3d9(device, 0, 0);
+        ok(compare_vec4(&v, 0.02f, 0.245f, 0.351f, 1.0f, 0),
+                "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);

-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, vec4_indexing_test2_probes,
-                ARRAY_SIZE(vec4_indexing_test2_probes), 32, 1, __LINE__);
+        ID3D10Blob_Release(ps_code);
+    }

+    todo_wine ps_code = compile_shader(ps_uniform_indexing_source, "ps_2_0");
+    if (ps_code)
+    {
+        hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(ps_code), &constants);
+        ok(hr == D3D_OK, "Failed to get constants, hr %#x.\n", hr);
+        hr = ID3DXConstantTable_SetInt(constants, device, "i", 2);
+        ok(hr == D3D_OK, "Failed to set constant, hr %#x.\n", hr);
         ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+        draw_quad(device, ps_code);
+
+        v = get_readback_vec4_d3d9(device, 0, 0);
+        ok(compare_vec4(&v, 0.5f, 0.3f, 0.8f, 0.2f, 0),
+                "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+
+        ID3D10Blob_Release(ps_code);
     }
+
+    IDirect3DDevice9_Release(device);
+    DestroyWindow(window);
 }

-static void test_trig(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
-        IDirect3DVertexShader9 *vshader_passthru)
+static void test_trig(void)
 {
-    static const struct hlsl_probe_info sincos_probes[] =
-    {
-        {0, 0, {0.5000f, 1.0000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {1, 0, {0.5975f, 0.9904f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {2, 0, {0.6913f, 0.9620f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {3, 0, {0.7778f, 0.9160f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {4, 0, {0.8536f, 0.8536f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {5, 0, {0.9157f, 0.7778f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {6, 0, {0.9620f, 0.6913f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {7, 0, {0.9904f, 0.5975f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {8, 0, {1.0000f, 0.5000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {9, 0, {0.9904f, 0.4025f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {10, 0, {0.9619f, 0.3087f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {11, 0, {0.9157f, 0.2222f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {12, 0, {0.8536f, 0.1464f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {13, 0, {0.7778f, 0.0843f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {14, 0, {0.6913f, 0.0381f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {15, 0, {0.5975f, 0.0096f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {16, 0, {0.5000f, 0.0000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {17, 0, {0.4025f, 0.0096f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {18, 0, {0.3087f, 0.0381f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {19, 0, {0.2222f, 0.0843f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {20, 0, {0.1464f, 0.1464f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {21, 0, {0.0843f, 0.2222f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {22, 0, {0.0381f, 0.3087f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {23, 0, {0.0096f, 0.4025f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {24, 0, {0.0000f, 0.5000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {25, 0, {0.0096f, 0.5975f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {26, 0, {0.0381f, 0.6913f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {27, 0, {0.0843f, 0.7778f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {28, 0, {0.1464f, 0.8536f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {29, 0, {0.2222f, 0.9157f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {30, 0, {0.3087f, 0.9619f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-        {31, 0, {0.4025f, 0.9904f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
-    };
+    IDirect3DDevice9 *device;
+    ID3D10Blob *ps_code;
+    unsigned int i;
+    struct vec4 v;
+    HWND window;

-    static const char *sincos_shader =
-        "float4 test(float x: TEXCOORD0): COLOR\n"
+    static const char ps_source[] =
+        "float4 main(float x : TEXCOORD0) : COLOR\n"
         "{\n"
         "    const float pi2 = 6.2831853;\n"
         "    float calcd_sin = (sin(x * pi2) + 1)/2;\n"
@@ -548,22 +534,37 @@ static void test_trig(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geo
         "    return float4(calcd_sin, calcd_cos, 0, 0);\n"
         "}";

-    ID3DXConstantTable *constants;
-    IDirect3DPixelShader9 *pshader;
+    window = create_window();
+    ok(!!window, "Failed to create a window.\n");
+
+    if (!(device = create_d3d9_device(window)))
+    {
+        DestroyWindow(window);
+        return;
+    }

-    pshader = compile_pixel_shader9(device, sincos_shader, "ps_2_0", &constants);
-    if (pshader != NULL)
+    todo_wine ps_code = compile_shader(ps_source, "ps_2_0");
+    if (ps_code)
     {
-        compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, sincos_probes,
-                ARRAY_SIZE(sincos_probes), 32, 1, __LINE__);
+        draw_quad(device, ps_code);

-        ID3DXConstantTable_Release(constants);
-        IDirect3DPixelShader9_Release(pshader);
+        for (i = 0; i < 32; ++i)
+        {
+            float expect_x = (sinf(i * 2 * M_PI / 32) + 1.0f) / 2.0f;
+            float expect_y = (cosf(i * 2 * M_PI / 32) + 1.0f) / 2.0f;
+            v = get_readback_vec4_d3d9(device, i * 640 / 32, 0);
+            ok(compare_vec4(&v, expect_x, expect_y, 0.0f, 0.0f, 4096),
+                    "Test %u: Got {%.8e, %.8e, %.8e, %.8e}, expected {%.8e, %.8e, %.8e, %.8e}.\n",
+                    i, v.x, v.y, v.z, v.w, expect_x, expect_y, 0.0f, 0.0f);
+        }
+
+        ID3D10Blob_Release(ps_code);
     }
+    IDirect3DDevice9_Release(device);
+    DestroyWindow(window);
 }

-static void test_fail(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *qquad_geometry,
-        IDirect3DVertexShader9 *vshader_passthru)
+static void test_fail(void)
 {
     static const char *tests[] =
     {
@@ -619,10 +620,11 @@ static void test_fail(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *qquad_ge
     {
         compiled = errors = NULL;
         hr = ppD3DCompile(tests[i], strlen(tests[i]), NULL, NULL, NULL, "test", "ps_2_0", 0, 0, &compiled, &errors);
-        ok(hr == E_FAIL, "Test %u, got unexpected hr %#x.\n", i, hr);
-        ok(!!errors, "Test %u, expected non-NULL error blob.\n", i);
+        todo_wine ok(hr == E_FAIL, "Test %u, got unexpected hr %#x.\n", i, hr);
+        todo_wine_if (i == 1) ok(!!errors, "Test %u, expected non-NULL error blob.\n", i);
         ok(!compiled, "Test %u, expected no compiled shader blob.\n", i);
-        ID3D10Blob_Release(errors);
+        if (errors)
+            ID3D10Blob_Release(errors);
     }
 }

@@ -642,12 +644,6 @@ static BOOL load_d3dcompiler(void)

START_TEST(hlsl)
 {
-    D3DCAPS9 caps;
-    ULONG refcount;
-    IDirect3DDevice9 *device;
-    IDirect3DVertexDeclaration9 *vdeclaration;
-    IDirect3DVertexBuffer9 *quad_geometry;
-    IDirect3DVertexShader9 *vshader_passthru;
     HMODULE mod;

if (!load_d3dcompiler())
@@ -662,40 +658,11 @@ START_TEST(hlsl)
         return;
     }
     pD3DXGetShaderConstantTable = (void *)GetProcAddress(mod, "D3DXGetShaderConstantTable");
-    pD3DXMatrixOrthoLH = (void *)GetProcAddress(mod, "D3DXMatrixOrthoLH");
-
-    device = init_d3d9(&vdeclaration, &quad_geometry, &vshader_passthru);
-    if (!device) return;
-
-    /* Make sure we support pixel shaders, before trying to compile them! */
-    /* Direct3D 9 (Shader model 1-3 tests) */
-    IDirect3DDevice9_GetDeviceCaps(device, &caps);
-    if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0))
-    {
-        todo_wine
-        {
-            test_swizzle(device, quad_geometry, vshader_passthru);
-            test_math(device, quad_geometry, vshader_passthru);
-            test_conditionals(device, quad_geometry, vshader_passthru);
-            test_float_vectors(device, quad_geometry, vshader_passthru);
-            test_trig(device, quad_geometry, vshader_passthru);
-            test_fail(device, quad_geometry, vshader_passthru);
-        }
-    } else skip("no pixel shader support\n");
-
-    /* Reference counting sanity checks */
-    if (vshader_passthru)
-    {
-        refcount = IDirect3DVertexShader9_Release(vshader_passthru);
-        ok(!refcount, "Pass-through vertex shader has %u references left\n", refcount);
-    }
-
-    refcount = IDirect3DVertexBuffer9_Release(quad_geometry);
-    ok(!refcount, "Vertex buffer has %u references left\n", refcount);
-
-    refcount = IDirect3DVertexDeclaration9_Release(vdeclaration);
-    ok(!refcount, "Vertex declaration has %u references left\n", refcount);

-    refcount = IDirect3DDevice9_Release(device);
-    ok(!refcount, "Device has %u references left\n", refcount);
+    test_swizzle();
+    test_math();
+    test_conditionals();
+    test_float_vectors();
+    test_trig();
+    test_fail();
 }