[PATCH 1/4] wined3d: Simplify code paths in wined3d_cs_exec_update_sub_resource().

[Józef Kucia]

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com>
---
 dlls/wined3d/cs.c | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c
index 78443d174a27..bb9b915a5980 100644
--- a/dlls/wined3d/cs.c
+++ b/dlls/wined3d/cs.c
@@ -2170,31 +2170,31 @@ void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_reso
 static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const void *data)
 {
     const struct wined3d_cs_update_sub_resource *op = data;
+    struct wined3d_resource *resource = op->resource;
     const struct wined3d_box *box = &op->box;
     unsigned int width, height, depth, level;
     struct wined3d_const_bo_address addr;
     struct wined3d_context *context;
     struct wined3d_texture *texture;
 
-    if (op->resource->type == WINED3D_RTYPE_BUFFER)
+    context = context_acquire(cs->device, NULL, 0);
+
+    if (resource->type == WINED3D_RTYPE_BUFFER)
     {
-        struct wined3d_buffer *buffer = buffer_from_resource(op->resource);
+        struct wined3d_buffer *buffer = buffer_from_resource(resource);
 
-        context = context_acquire(op->resource->device, NULL, 0);
         if (!wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER))
         {
             ERR("Failed to load buffer location.\n");
-            context_release(context);
             goto done;
         }
 
         wined3d_buffer_upload_data(buffer, context, box, op->data.data);
         wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER);
-        context_release(context);
         goto done;
     }
 
-    texture = wined3d_texture_from_resource(op->resource);
+    texture = wined3d_texture_from_resource(resource);
 
     level = op->sub_resource_idx % texture->level_count;
     width = wined3d_texture_get_level_width(texture, level);
@@ -2204,8 +2204,6 @@ static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const voi
     addr.buffer_object = 0;
     addr.addr = op->data.data;
 
-    context = context_acquire(op->resource->device, NULL, 0);
-
     /* Only load the sub-resource for partial updates. */
     if (!box->left && !box->top && !box->front
             && box->right == width && box->bottom == height && box->back == depth)
@@ -2217,13 +2215,13 @@ static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const voi
     wined3d_texture_upload_data(texture, op->sub_resource_idx, context,
             box, &addr, op->data.row_pitch, op->data.slice_pitch);
 
-    context_release(context);
-
     wined3d_texture_validate_location(texture, op->sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
     wined3d_texture_invalidate_location(texture, op->sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
 
 done:
-    wined3d_resource_release(op->resource);
+    context_release(context);
+
+    wined3d_resource_release(resource);
 }
 
 void wined3d_cs_emit_update_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *resource,
-- 
2.13.6

[PATCH 2/4] d3d11: Validate resource access flags for buffers and 2D textures.

[Józef Kucia]

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com>
---
 dlls/d3d11/buffer.c        |  8 +++--
 dlls/d3d11/d3d11_private.h |  4 +++
 dlls/d3d11/texture.c       |  8 +++--
 dlls/d3d11/utils.c         | 88 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 104 insertions(+), 4 deletions(-)

diff --git a/dlls/d3d11/buffer.c b/dlls/d3d11/buffer.c
index 3ccccc8cc861..ffa95a19396c 100644
--- a/dlls/d3d11/buffer.c
+++ b/dlls/d3d11/buffer.c
@@ -387,8 +387,12 @@ static const struct wined3d_parent_ops d3d_buffer_wined3d_parent_ops =
     d3d_buffer_wined3d_object_released,
 };
 
-static BOOL validate_buffer_desc(D3D11_BUFFER_DESC *desc)
+static BOOL validate_buffer_desc(D3D11_BUFFER_DESC *desc, D3D_FEATURE_LEVEL feature_level)
 {
+    if (!validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION_BUFFER,
+            desc->Usage, desc->BindFlags, desc->CPUAccessFlags, feature_level))
+        return FALSE;
+
     if (desc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS)
     {
         if (desc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
@@ -442,7 +446,7 @@ static HRESULT d3d_buffer_init(struct d3d_buffer *buffer, struct d3d_device *dev
     buffer->refcount = 1;
     buffer->desc = *desc;
 
-    if (!validate_buffer_desc(&buffer->desc))
+    if (!validate_buffer_desc(&buffer->desc, device->feature_level))
         return E_INVALIDARG;
 
     wined3d_desc.byte_width = buffer->desc.ByteWidth;
diff --git a/dlls/d3d11/d3d11_private.h b/dlls/d3d11/d3d11_private.h
index c286e768d9cb..6702248e6958 100644
--- a/dlls/d3d11/d3d11_private.h
+++ b/dlls/d3d11/d3d11_private.h
@@ -83,6 +83,10 @@ UINT d3d10_cpu_access_flags_from_d3d11_cpu_access_flags(UINT cpu_access_flags) D
 UINT d3d11_resource_misc_flags_from_d3d10_resource_misc_flags(UINT resource_misc_flags) DECLSPEC_HIDDEN;
 UINT d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(UINT resource_misc_flags) DECLSPEC_HIDDEN;
 
+BOOL validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION resource_dimension,
+        D3D11_USAGE usage, UINT bind_flags, UINT cpu_access_flags,
+        D3D_FEATURE_LEVEL feature_level) DECLSPEC_HIDDEN;
+
 HRESULT d3d_get_private_data(struct wined3d_private_store *store,
         REFGUID guid, UINT *data_size, void *data) DECLSPEC_HIDDEN;
 HRESULT d3d_set_private_data(struct wined3d_private_store *store,
diff --git a/dlls/d3d11/texture.c b/dlls/d3d11/texture.c
index 2644b52dfa25..a35a9ac9a219 100644
--- a/dlls/d3d11/texture.c
+++ b/dlls/d3d11/texture.c
@@ -456,8 +456,12 @@ static BOOL is_gdi_compatible_texture(const D3D11_TEXTURE2D_DESC *desc)
     return TRUE;
 }
 
-static BOOL validate_texture2d_desc(const D3D11_TEXTURE2D_DESC *desc)
+static BOOL validate_texture2d_desc(const D3D11_TEXTURE2D_DESC *desc, D3D_FEATURE_LEVEL feature_level)
 {
+    if (!validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION_TEXTURE2D,
+            desc->Usage, desc->BindFlags, desc->CPUAccessFlags, feature_level))
+        return FALSE;
+
     if (desc->MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE
             && desc->ArraySize < 6)
     {
@@ -492,7 +496,7 @@ HRESULT d3d_texture2d_create(struct d3d_device *device, const D3D11_TEXTURE2D_DE
     DWORD flags = 0;
     HRESULT hr;
 
-    if (!validate_texture2d_desc(desc))
+    if (!validate_texture2d_desc(desc, device->feature_level))
     {
         WARN("Failed to validate texture desc.\n");
         return E_INVALIDARG;
diff --git a/dlls/d3d11/utils.c b/dlls/d3d11/utils.c
index ae761f448b74..b3894bbfa585 100644
--- a/dlls/d3d11/utils.c
+++ b/dlls/d3d11/utils.c
@@ -610,6 +610,94 @@ UINT d3d10_resource_misc_flags_from_d3d11_resource_misc_flags(UINT resource_misc
     return d3d10_resource_misc_flags;
 }
 
+static BOOL d3d11_bind_flags_are_gpu_read_only(UINT bind_flags)
+{
+    static const BOOL read_only_bind_flags = D3D11_BIND_VERTEX_BUFFER
+            | D3D11_BIND_INDEX_BUFFER | D3D11_BIND_CONSTANT_BUFFER
+            | D3D11_BIND_SHADER_RESOURCE;
+
+    return !(bind_flags & ~read_only_bind_flags);
+}
+
+BOOL validate_d3d11_resource_access_flags(D3D11_RESOURCE_DIMENSION resource_dimension,
+        D3D11_USAGE usage, UINT bind_flags, UINT cpu_access_flags, D3D_FEATURE_LEVEL feature_level)
+{
+    const BOOL is_texture = resource_dimension != D3D11_RESOURCE_DIMENSION_BUFFER;
+
+    switch (usage)
+    {
+        case D3D11_USAGE_DEFAULT:
+            if ((bind_flags == D3D11_BIND_SHADER_RESOURCE && feature_level >= D3D_FEATURE_LEVEL_11_0)
+                    || (is_texture && bind_flags == D3D11_BIND_RENDER_TARGET)
+                    || bind_flags == D3D11_BIND_UNORDERED_ACCESS)
+                break;
+            if (cpu_access_flags)
+            {
+                WARN("Default resources are not CPU accessible.\n");
+                return FALSE;
+            }
+            break;
+
+        case D3D11_USAGE_IMMUTABLE:
+            if (!bind_flags)
+            {
+                WARN("Bind flags must be non-zero for immutable resources.\n");
+                return FALSE;
+            }
+            if (!d3d11_bind_flags_are_gpu_read_only(bind_flags))
+            {
+                WARN("Immutable resources cannot be writable by GPU.\n");
+                return FALSE;
+            }
+
+            if (cpu_access_flags)
+            {
+                WARN("Immutable resources are not CPU accessible.\n");
+                return FALSE;
+            }
+            break;
+
+        case D3D11_USAGE_DYNAMIC:
+            if (!bind_flags)
+            {
+                WARN("Bind flags must be non-zero for dynamic resources.\n");
+                return FALSE;
+            }
+            if (!d3d11_bind_flags_are_gpu_read_only(bind_flags))
+            {
+                WARN("Dynamic resources cannot be writable by GPU.\n");
+                return FALSE;
+            }
+
+            if (cpu_access_flags != D3D11_CPU_ACCESS_WRITE)
+            {
+                WARN("CPU access must be D3D11_CPU_ACCESS_WRITE for dynamic resources.\n");
+                return FALSE;
+            }
+            break;
+
+        case D3D11_USAGE_STAGING:
+            if (bind_flags)
+            {
+                WARN("Invalid bind flags %#x for staging resources.\n", bind_flags);
+                return FALSE;
+            }
+
+            if (!cpu_access_flags)
+            {
+                WARN("CPU access must be non-zero for staging resources.\n");
+                return FALSE;
+            }
+            break;
+
+        default:
+            WARN("Invalid usage %#x.\n", usage);
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
 struct wined3d_resource *wined3d_resource_from_d3d11_resource(ID3D11Resource *resource)
 {
     D3D11_RESOURCE_DIMENSION dimension;
-- 
2.13.6

[PATCH 3/4] d3d11/tests: Add test for resource access flags.

[Józef Kucia]

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com>
---
 dlls/d3d11/tests/d3d11.c | 373 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 372 insertions(+), 1 deletion(-)

diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c
index ca71718c4e9b..fc3b23d744b0 100644
--- a/dlls/d3d11/tests/d3d11.c
+++ b/dlls/d3d11/tests/d3d11.c
@@ -24,7 +24,7 @@
 #include <stdlib.h>
 #define COBJMACROS
 #include "initguid.h"
-#include "d3d11_1.h"
+#include "d3d11_4.h"
 #include "wine/test.h"
 
 #ifndef ARRAY_SIZE
@@ -1092,6 +1092,36 @@ static BOOL is_nvidia_device(ID3D11Device *device)
     return is_vendor_device(device, 0x10de);
 }
 
+static BOOL is_d3d11_1_runtime(ID3D11Device *device)
+{
+    ID3D11Device1 *device1;
+    HRESULT hr;
+
+    /* FIXME: Wine doesn't implement required interfaces yet, but we want to test new behavior. */
+    if (!strcmp(winetest_platform, "wine"))
+        return TRUE;
+
+    hr = ID3D11Device_QueryInterface(device, &IID_ID3D11Device1, (void **)&device1);
+    if (SUCCEEDED(hr))
+        ID3D11Device1_Release(device1);
+    return hr == S_OK;
+}
+
+static BOOL is_d3d11_2_runtime(ID3D11Device *device)
+{
+    ID3D11Device2 *device2;
+    HRESULT hr;
+
+    /* FIXME: Wine doesn't implement required interfaces yet, but we want to test new behavior. */
+    if (!strcmp(winetest_platform, "wine"))
+        return TRUE;
+
+    hr = ID3D11Device_QueryInterface(device, &IID_ID3D11Device2, (void **)&device2);
+    if (SUCCEEDED(hr))
+        ID3D11Device2_Release(device2);
+    return hr == S_OK;
+}
+
 static BOOL check_compute_shaders_via_sm4_support(ID3D11Device *device)
 {
     D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS options;
@@ -1102,6 +1132,13 @@ static BOOL check_compute_shaders_via_sm4_support(ID3D11Device *device)
     return options.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x;
 }
 
+static BOOL is_buffer(ID3D11Resource *resource)
+{
+    D3D11_RESOURCE_DIMENSION dimension;
+    ID3D11Resource_GetType(resource, &dimension);
+    return dimension == D3D11_RESOURCE_DIMENSION_BUFFER;
+}
+
 static IDXGISwapChain *create_swapchain(ID3D11Device *device, HWND window,
         const struct swapchain_desc *swapchain_desc)
 {
@@ -10928,6 +10965,339 @@ static void test_resource_map(void)
     ok(!refcount, "Device has %u references left.\n", refcount);
 }
 
+#define check_resource_cpu_access(a, b, c, d, e) check_resource_cpu_access_(__LINE__, a, b, c, d, e)
+static void check_resource_cpu_access_(unsigned int line, ID3D11DeviceContext *context,
+        ID3D11Resource *resource, D3D11_USAGE usage, UINT bind_flags, UINT cpu_access)
+{
+    BOOL cpu_write = cpu_access & D3D11_CPU_ACCESS_WRITE;
+    BOOL cpu_read = cpu_access & D3D11_CPU_ACCESS_READ;
+    BOOL dynamic = usage == D3D11_USAGE_DYNAMIC;
+    D3D11_MAPPED_SUBRESOURCE map_desc;
+    HRESULT hr, expected_hr;
+    ID3D11Device *device;
+
+    expected_hr = cpu_read ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_READ, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    /* WRITE_DISCARD and WRITE_NO_OVERWRITE are the only allowed options for dynamic resources. */
+    expected_hr = !dynamic && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    expected_hr = cpu_read && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_READ_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ_WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    expected_hr = dynamic ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_DISCARD.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    if (!dynamic)
+        return;
+
+    ID3D11DeviceContext_GetDevice(context, &device);
+
+    /* WRITE_NO_OVERWRITE is supported only for buffers. */
+    expected_hr = is_buffer(resource) ? S_OK : E_INVALIDARG;
+    /* D3D11.1 is required for constant and shader buffers. */
+    if (bind_flags & (D3D11_BIND_CONSTANT_BUFFER | D3D11_BIND_SHADER_RESOURCE) && !is_d3d11_1_runtime(device))
+        expected_hr = E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_NO_OVERWRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    ID3D11Device_Release(device);
+}
+
+static void test_resource_access(const D3D_FEATURE_LEVEL feature_level)
+{
+    D3D11_TEXTURE2D_DESC texture_desc;
+    struct device_desc device_desc;
+    D3D11_BUFFER_DESC buffer_desc;
+    ID3D11DeviceContext *context;
+    D3D11_SUBRESOURCE_DATA data;
+    ID3D11Resource *resource;
+    BOOL required_cpu_access;
+    BOOL cpu_write, cpu_read;
+    HRESULT hr, expected_hr;
+    UINT allowed_cpu_access;
+    BOOL broken_validation;
+    ID3D11Device *device;
+    unsigned int i;
+    ULONG refcount;
+
+    static const struct
+    {
+        D3D11_USAGE usage;
+        UINT bind_flags;
+        BOOL is_valid;
+        UINT allowed_cpu_access;
+        UINT allowed_texture_cpu_access;
+    }
+    tests[] =
+    {
+        /* Default resources cannot be written by CPU. */
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_VERTEX_BUFFER,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_INDEX_BUFFER,     TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_CONSTANT_BUFFER,  TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE,  TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_STREAM_OUTPUT,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_RENDER_TARGET,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_DEPTH_STENCIL,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_UNORDERED_ACCESS, TRUE, 0},
+
+        /* Immutable resources cannot be written by CPU and GPU. */
+        {D3D11_USAGE_IMMUTABLE, 0,                           FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_VERTEX_BUFFER,    TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_INDEX_BUFFER,     TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_CONSTANT_BUFFER,  TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_SHADER_RESOURCE,  TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_STREAM_OUTPUT,    FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_RENDER_TARGET,    FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_DEPTH_STENCIL,    FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_UNORDERED_ACCESS, FALSE, 0},
+
+        /* Dynamic resources cannot be written by GPU. */
+        {D3D11_USAGE_DYNAMIC, 0,                           FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_VERTEX_BUFFER,    TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_INDEX_BUFFER,     TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER,  TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_SHADER_RESOURCE,  TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_STREAM_OUTPUT,    FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_RENDER_TARGET,    FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_DEPTH_STENCIL,    FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_UNORDERED_ACCESS, FALSE, D3D11_CPU_ACCESS_WRITE},
+
+        /* Staging resources support only data transfer. */
+        {D3D11_USAGE_STAGING, 0,                           TRUE,  D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ},
+        {D3D11_USAGE_STAGING, D3D11_BIND_VERTEX_BUFFER,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_INDEX_BUFFER,     FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_CONSTANT_BUFFER,  FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_SHADER_RESOURCE,  FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_STREAM_OUTPUT,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_RENDER_TARGET,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_DEPTH_STENCIL,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_UNORDERED_ACCESS, FALSE, 0},
+    };
+
+    device_desc.feature_level = &feature_level;
+    device_desc.flags = 0;
+    if (!(device = create_device(&device_desc)))
+    {
+        skip("Failed to create device for feature level %#x.\n", feature_level);
+        return;
+    }
+    ID3D11Device_GetImmediateContext(device, &context);
+
+    data.SysMemPitch = 0;
+    data.SysMemSlicePitch = 0;
+    data.pSysMem = HeapAlloc(GetProcessHeap(), 0, 10240);
+    ok(!!data.pSysMem, "Failed to allocate memory.\n");
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        switch (tests[i].bind_flags)
+        {
+            case D3D11_BIND_DEPTH_STENCIL:
+                continue;
+
+            case D3D11_BIND_SHADER_RESOURCE:
+            case D3D11_BIND_STREAM_OUTPUT:
+            case D3D11_BIND_RENDER_TARGET:
+                if (feature_level < D3D_FEATURE_LEVEL_10_0)
+                    continue;
+                break;
+
+            case D3D11_BIND_UNORDERED_ACCESS:
+                if (feature_level < D3D_FEATURE_LEVEL_11_0)
+                    continue;
+                break;
+
+            default:
+                break;
+        }
+
+        allowed_cpu_access = tests[i].allowed_cpu_access;
+        if (feature_level >= D3D_FEATURE_LEVEL_11_0 && is_d3d11_2_runtime(device)
+                && tests[i].usage == D3D11_USAGE_DEFAULT
+                && (tests[i].bind_flags == D3D11_BIND_SHADER_RESOURCE
+                || tests[i].bind_flags == D3D11_BIND_UNORDERED_ACCESS))
+            allowed_cpu_access |= D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+
+        required_cpu_access = tests[i].usage == D3D11_USAGE_DYNAMIC || tests[i].usage == D3D11_USAGE_STAGING;
+        cpu_write = allowed_cpu_access & D3D11_CPU_ACCESS_WRITE;
+        cpu_read = allowed_cpu_access & D3D11_CPU_ACCESS_READ;
+
+        buffer_desc.ByteWidth = 1024;
+        buffer_desc.Usage = tests[i].usage;
+        buffer_desc.BindFlags = tests[i].bind_flags;
+        buffer_desc.MiscFlags = 0;
+        buffer_desc.StructureByteStride = 0;
+
+        buffer_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+    }
+
+    data.SysMemPitch = 16;
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        switch (tests[i].bind_flags)
+        {
+            case D3D11_BIND_VERTEX_BUFFER:
+            case D3D11_BIND_INDEX_BUFFER:
+            case D3D11_BIND_CONSTANT_BUFFER:
+            case D3D11_BIND_STREAM_OUTPUT:
+                continue;
+
+            case D3D11_BIND_UNORDERED_ACCESS:
+                if (feature_level < D3D_FEATURE_LEVEL_11_0)
+                    continue;
+                break;
+
+            default:
+                break;
+        }
+
+        broken_validation = tests[i].usage == D3D11_USAGE_DEFAULT
+                && (tests[i].bind_flags == D3D11_BIND_SHADER_RESOURCE
+                || tests[i].bind_flags == D3D11_BIND_RENDER_TARGET
+                || tests[i].bind_flags == D3D11_BIND_UNORDERED_ACCESS);
+
+        required_cpu_access = tests[i].usage == D3D11_USAGE_DYNAMIC || tests[i].usage == D3D11_USAGE_STAGING;
+        cpu_write = tests[i].allowed_cpu_access & D3D11_CPU_ACCESS_WRITE;
+        cpu_read = tests[i].allowed_cpu_access & D3D11_CPU_ACCESS_READ;
+
+        texture_desc.Width = 4;
+        texture_desc.Height = 4;
+        texture_desc.MipLevels = 1;
+        texture_desc.ArraySize = 1;
+        texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        texture_desc.SampleDesc.Count = 1;
+        texture_desc.SampleDesc.Quality = 0;
+        texture_desc.Usage = tests[i].usage;
+        texture_desc.BindFlags = tests[i].bind_flags;
+        texture_desc.MiscFlags = 0;
+        if (tests[i].bind_flags == D3D11_BIND_DEPTH_STENCIL)
+            texture_desc.Format = DXGI_FORMAT_D16_UNORM;
+
+        texture_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+    }
+
+    HeapFree(GetProcessHeap(), 0, (void *)data.pSysMem);
+
+    ID3D11DeviceContext_Release(context);
+    refcount = ID3D11Device_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+}
+
 static void test_check_multisample_quality_levels(void)
 {
     ID3D11Device *device;
@@ -24425,6 +24795,7 @@ START_TEST(d3d11)
     test_update_subresource();
     test_copy_subresource_region();
     test_resource_map();
+    run_for_each_feature_level(test_resource_access);
     test_check_multisample_quality_levels();
     run_for_each_feature_level(test_swapchain_formats);
     test_swapchain_views();
-- 
2.13.6

[PATCH v2 3/4] d3d11/tests: Add test for resource access flags.

[Józef Kucia]

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com>
---

Version 2: Remove allowed_texture_cpu_access.

---
 dlls/d3d11/tests/d3d11.c | 372 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 371 insertions(+), 1 deletion(-)

diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c
index ca71718c4e9b..29ea2b376e7c 100644
--- a/dlls/d3d11/tests/d3d11.c
+++ b/dlls/d3d11/tests/d3d11.c
@@ -24,7 +24,7 @@
 #include <stdlib.h>
 #define COBJMACROS
 #include "initguid.h"
-#include "d3d11_1.h"
+#include "d3d11_4.h"
 #include "wine/test.h"
 
 #ifndef ARRAY_SIZE
@@ -1092,6 +1092,36 @@ static BOOL is_nvidia_device(ID3D11Device *device)
     return is_vendor_device(device, 0x10de);
 }
 
+static BOOL is_d3d11_1_runtime(ID3D11Device *device)
+{
+    ID3D11Device1 *device1;
+    HRESULT hr;
+
+    /* FIXME: Wine doesn't implement required interfaces yet, but we want to test new behavior. */
+    if (!strcmp(winetest_platform, "wine"))
+        return TRUE;
+
+    hr = ID3D11Device_QueryInterface(device, &IID_ID3D11Device1, (void **)&device1);
+    if (SUCCEEDED(hr))
+        ID3D11Device1_Release(device1);
+    return hr == S_OK;
+}
+
+static BOOL is_d3d11_2_runtime(ID3D11Device *device)
+{
+    ID3D11Device2 *device2;
+    HRESULT hr;
+
+    /* FIXME: Wine doesn't implement required interfaces yet, but we want to test new behavior. */
+    if (!strcmp(winetest_platform, "wine"))
+        return TRUE;
+
+    hr = ID3D11Device_QueryInterface(device, &IID_ID3D11Device2, (void **)&device2);
+    if (SUCCEEDED(hr))
+        ID3D11Device2_Release(device2);
+    return hr == S_OK;
+}
+
 static BOOL check_compute_shaders_via_sm4_support(ID3D11Device *device)
 {
     D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS options;
@@ -1102,6 +1132,13 @@ static BOOL check_compute_shaders_via_sm4_support(ID3D11Device *device)
     return options.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x;
 }
 
+static BOOL is_buffer(ID3D11Resource *resource)
+{
+    D3D11_RESOURCE_DIMENSION dimension;
+    ID3D11Resource_GetType(resource, &dimension);
+    return dimension == D3D11_RESOURCE_DIMENSION_BUFFER;
+}
+
 static IDXGISwapChain *create_swapchain(ID3D11Device *device, HWND window,
         const struct swapchain_desc *swapchain_desc)
 {
@@ -10928,6 +10965,338 @@ static void test_resource_map(void)
     ok(!refcount, "Device has %u references left.\n", refcount);
 }
 
+#define check_resource_cpu_access(a, b, c, d, e) check_resource_cpu_access_(__LINE__, a, b, c, d, e)
+static void check_resource_cpu_access_(unsigned int line, ID3D11DeviceContext *context,
+        ID3D11Resource *resource, D3D11_USAGE usage, UINT bind_flags, UINT cpu_access)
+{
+    BOOL cpu_write = cpu_access & D3D11_CPU_ACCESS_WRITE;
+    BOOL cpu_read = cpu_access & D3D11_CPU_ACCESS_READ;
+    BOOL dynamic = usage == D3D11_USAGE_DYNAMIC;
+    D3D11_MAPPED_SUBRESOURCE map_desc;
+    HRESULT hr, expected_hr;
+    ID3D11Device *device;
+
+    expected_hr = cpu_read ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_READ, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    /* WRITE_DISCARD and WRITE_NO_OVERWRITE are the only allowed options for dynamic resources. */
+    expected_hr = !dynamic && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    expected_hr = cpu_read && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_READ_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ_WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    expected_hr = dynamic ? S_OK : E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_DISCARD.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    if (!dynamic)
+        return;
+
+    ID3D11DeviceContext_GetDevice(context, &device);
+
+    /* WRITE_NO_OVERWRITE is supported only for buffers. */
+    expected_hr = is_buffer(resource) ? S_OK : E_INVALIDARG;
+    /* D3D11.1 is required for constant and shader buffers. */
+    if (bind_flags & (D3D11_BIND_CONSTANT_BUFFER | D3D11_BIND_SHADER_RESOURCE) && !is_d3d11_1_runtime(device))
+        expected_hr = E_INVALIDARG;
+    hr = ID3D11DeviceContext_Map(context, resource, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_NO_OVERWRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D11DeviceContext_Unmap(context, resource, 0);
+
+    ID3D11Device_Release(device);
+}
+
+static void test_resource_access(const D3D_FEATURE_LEVEL feature_level)
+{
+    D3D11_TEXTURE2D_DESC texture_desc;
+    struct device_desc device_desc;
+    D3D11_BUFFER_DESC buffer_desc;
+    ID3D11DeviceContext *context;
+    D3D11_SUBRESOURCE_DATA data;
+    ID3D11Resource *resource;
+    BOOL required_cpu_access;
+    BOOL cpu_write, cpu_read;
+    HRESULT hr, expected_hr;
+    UINT allowed_cpu_access;
+    BOOL broken_validation;
+    ID3D11Device *device;
+    unsigned int i;
+    ULONG refcount;
+
+    static const struct
+    {
+        D3D11_USAGE usage;
+        UINT bind_flags;
+        BOOL is_valid;
+        UINT allowed_cpu_access;
+    }
+    tests[] =
+    {
+        /* Default resources cannot be written by CPU. */
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_VERTEX_BUFFER,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_INDEX_BUFFER,     TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_CONSTANT_BUFFER,  TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE,  TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_STREAM_OUTPUT,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_RENDER_TARGET,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_DEPTH_STENCIL,    TRUE, 0},
+        {D3D11_USAGE_DEFAULT, D3D11_BIND_UNORDERED_ACCESS, TRUE, 0},
+
+        /* Immutable resources cannot be written by CPU and GPU. */
+        {D3D11_USAGE_IMMUTABLE, 0,                           FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_VERTEX_BUFFER,    TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_INDEX_BUFFER,     TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_CONSTANT_BUFFER,  TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_SHADER_RESOURCE,  TRUE,  0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_STREAM_OUTPUT,    FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_RENDER_TARGET,    FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_DEPTH_STENCIL,    FALSE, 0},
+        {D3D11_USAGE_IMMUTABLE, D3D11_BIND_UNORDERED_ACCESS, FALSE, 0},
+
+        /* Dynamic resources cannot be written by GPU. */
+        {D3D11_USAGE_DYNAMIC, 0,                           FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_VERTEX_BUFFER,    TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_INDEX_BUFFER,     TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER,  TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_SHADER_RESOURCE,  TRUE,  D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_STREAM_OUTPUT,    FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_RENDER_TARGET,    FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_DEPTH_STENCIL,    FALSE, D3D11_CPU_ACCESS_WRITE},
+        {D3D11_USAGE_DYNAMIC, D3D11_BIND_UNORDERED_ACCESS, FALSE, D3D11_CPU_ACCESS_WRITE},
+
+        /* Staging resources support only data transfer. */
+        {D3D11_USAGE_STAGING, 0,                           TRUE,  D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ},
+        {D3D11_USAGE_STAGING, D3D11_BIND_VERTEX_BUFFER,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_INDEX_BUFFER,     FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_CONSTANT_BUFFER,  FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_SHADER_RESOURCE,  FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_STREAM_OUTPUT,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_RENDER_TARGET,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_DEPTH_STENCIL,    FALSE, 0},
+        {D3D11_USAGE_STAGING, D3D11_BIND_UNORDERED_ACCESS, FALSE, 0},
+    };
+
+    device_desc.feature_level = &feature_level;
+    device_desc.flags = 0;
+    if (!(device = create_device(&device_desc)))
+    {
+        skip("Failed to create device for feature level %#x.\n", feature_level);
+        return;
+    }
+    ID3D11Device_GetImmediateContext(device, &context);
+
+    data.SysMemPitch = 0;
+    data.SysMemSlicePitch = 0;
+    data.pSysMem = HeapAlloc(GetProcessHeap(), 0, 10240);
+    ok(!!data.pSysMem, "Failed to allocate memory.\n");
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        switch (tests[i].bind_flags)
+        {
+            case D3D11_BIND_DEPTH_STENCIL:
+                continue;
+
+            case D3D11_BIND_SHADER_RESOURCE:
+            case D3D11_BIND_STREAM_OUTPUT:
+            case D3D11_BIND_RENDER_TARGET:
+                if (feature_level < D3D_FEATURE_LEVEL_10_0)
+                    continue;
+                break;
+
+            case D3D11_BIND_UNORDERED_ACCESS:
+                if (feature_level < D3D_FEATURE_LEVEL_11_0)
+                    continue;
+                break;
+
+            default:
+                break;
+        }
+
+        allowed_cpu_access = tests[i].allowed_cpu_access;
+        if (feature_level >= D3D_FEATURE_LEVEL_11_0 && is_d3d11_2_runtime(device)
+                && tests[i].usage == D3D11_USAGE_DEFAULT
+                && (tests[i].bind_flags == D3D11_BIND_SHADER_RESOURCE
+                || tests[i].bind_flags == D3D11_BIND_UNORDERED_ACCESS))
+            allowed_cpu_access |= D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+
+        required_cpu_access = tests[i].usage == D3D11_USAGE_DYNAMIC || tests[i].usage == D3D11_USAGE_STAGING;
+        cpu_write = allowed_cpu_access & D3D11_CPU_ACCESS_WRITE;
+        cpu_read = allowed_cpu_access & D3D11_CPU_ACCESS_READ;
+
+        buffer_desc.ByteWidth = 1024;
+        buffer_desc.Usage = tests[i].usage;
+        buffer_desc.BindFlags = tests[i].bind_flags;
+        buffer_desc.MiscFlags = 0;
+        buffer_desc.StructureByteStride = 0;
+
+        buffer_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateBuffer(device, &buffer_desc, &data, (ID3D11Buffer **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    buffer_desc.Usage, buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+    }
+
+    data.SysMemPitch = 16;
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        switch (tests[i].bind_flags)
+        {
+            case D3D11_BIND_VERTEX_BUFFER:
+            case D3D11_BIND_INDEX_BUFFER:
+            case D3D11_BIND_CONSTANT_BUFFER:
+            case D3D11_BIND_STREAM_OUTPUT:
+                continue;
+
+            case D3D11_BIND_UNORDERED_ACCESS:
+                if (feature_level < D3D_FEATURE_LEVEL_11_0)
+                    continue;
+                break;
+
+            default:
+                break;
+        }
+
+        broken_validation = tests[i].usage == D3D11_USAGE_DEFAULT
+                && (tests[i].bind_flags == D3D11_BIND_SHADER_RESOURCE
+                || tests[i].bind_flags == D3D11_BIND_RENDER_TARGET
+                || tests[i].bind_flags == D3D11_BIND_UNORDERED_ACCESS);
+
+        required_cpu_access = tests[i].usage == D3D11_USAGE_DYNAMIC || tests[i].usage == D3D11_USAGE_STAGING;
+        cpu_write = tests[i].allowed_cpu_access & D3D11_CPU_ACCESS_WRITE;
+        cpu_read = tests[i].allowed_cpu_access & D3D11_CPU_ACCESS_READ;
+
+        texture_desc.Width = 4;
+        texture_desc.Height = 4;
+        texture_desc.MipLevels = 1;
+        texture_desc.ArraySize = 1;
+        texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        texture_desc.SampleDesc.Count = 1;
+        texture_desc.SampleDesc.Quality = 0;
+        texture_desc.Usage = tests[i].usage;
+        texture_desc.BindFlags = tests[i].bind_flags;
+        texture_desc.MiscFlags = 0;
+        if (tests[i].bind_flags == D3D11_BIND_DEPTH_STENCIL)
+            texture_desc.Format = DXGI_FORMAT_D16_UNORM;
+
+        texture_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+
+        texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D11Device_CreateTexture2D(device, &texture_desc, &data, (ID3D11Texture2D **)&resource);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_resource_cpu_access(context, resource,
+                    texture_desc.Usage, texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D11Resource_Release(resource);
+        }
+    }
+
+    HeapFree(GetProcessHeap(), 0, (void *)data.pSysMem);
+
+    ID3D11DeviceContext_Release(context);
+    refcount = ID3D11Device_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+}
+
 static void test_check_multisample_quality_levels(void)
 {
     ID3D11Device *device;
@@ -24425,6 +24794,7 @@ START_TEST(d3d11)
     test_update_subresource();
     test_copy_subresource_region();
     test_resource_map();
+    run_for_each_feature_level(test_resource_access);
     test_check_multisample_quality_levels();
     run_for_each_feature_level(test_swapchain_formats);
     test_swapchain_views();
-- 
2.13.6

[PATCH v2 3/4] d3d11/tests: Add test for resource access flags.

[Henri Verbeet]

On 30 January 2018 at 18:45, Józef Kucia <jkucia(a)codeweavers.com> wrote:
> dlls/d3d11/tests/d3d11.c | 372 ++++++++++++++++++++++++++++++++++++++++++++++-
>  1 file changed, 371 insertions(+), 1 deletion(-)

This fails here on Windows:

    d3d11.c:11169: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.
    d3d11.c:11169: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.
    d3d11.c:11169: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.
    d3d11.c:11169: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.
    d3d11.c:11169: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.
    d3d11.c:11169: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.

And likewise for d3d10core:

  device.c:8401: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.
  device.c:8401: Test failed: Got hr 0x80070057 for WRITE_NO_OVERWRITE.

[PATCH 4/4] d3d10core/tests: Add test for resource access flags.

[Józef Kucia]

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com>
---
 dlls/d3d10core/tests/device.c | 332 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 332 insertions(+)

diff --git a/dlls/d3d10core/tests/device.c b/dlls/d3d10core/tests/device.c
index 86a8f43d4e93..fedb2c2fa129 100644
--- a/dlls/d3d10core/tests/device.c
+++ b/dlls/d3d10core/tests/device.c
@@ -8186,6 +8186,337 @@ static void test_copy_subresource_region(void)
     release_test_context(&test_context);
 }
 
+#define check_buffer_cpu_access(a, b, c, d) check_buffer_cpu_access_(__LINE__, a, b, c, d)
+static void check_buffer_cpu_access_(unsigned int line, ID3D10Buffer *buffer,
+        D3D10_USAGE usage, UINT bind_flags, UINT cpu_access)
+{
+    BOOL cpu_write = cpu_access & D3D10_CPU_ACCESS_WRITE;
+    BOOL cpu_read = cpu_access & D3D10_CPU_ACCESS_READ;
+    BOOL dynamic = usage == D3D10_USAGE_DYNAMIC;
+    HRESULT hr, expected_hr;
+    ID3D10Device *device;
+    void *data;
+
+    expected_hr = cpu_read ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_READ, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    expected_hr = !dynamic && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_WRITE, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    expected_hr = cpu_read && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_READ_WRITE, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ_WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    expected_hr = dynamic ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_WRITE_DISCARD, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_DISCARD.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    if (!dynamic)
+        return;
+
+    ID3D10Buffer_GetDevice(buffer, &device);
+
+    expected_hr = S_OK;
+    if (bind_flags & (D3D10_BIND_CONSTANT_BUFFER | D3D10_BIND_SHADER_RESOURCE)
+            && !is_d3d11_interface_available(device))
+        expected_hr = E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_WRITE_NO_OVERWRITE, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_NO_OVERWRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    ID3D10Device_Release(device);
+}
+
+#define check_texture_cpu_access(a, b, c, d) check_texture_cpu_access_(__LINE__, a, b, c, d)
+static void check_texture_cpu_access_(unsigned int line, ID3D10Texture2D *texture,
+        D3D10_USAGE usage, UINT bind_flags, UINT cpu_access)
+{
+    BOOL cpu_write = cpu_access & D3D10_CPU_ACCESS_WRITE;
+    BOOL cpu_read = cpu_access & D3D10_CPU_ACCESS_READ;
+    BOOL dynamic = usage == D3D10_USAGE_DYNAMIC;
+    D3D10_MAPPED_TEXTURE2D map_desc;
+    HRESULT hr, expected_hr;
+
+    expected_hr = cpu_read ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_READ, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    expected_hr = !dynamic && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    expected_hr = cpu_read && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_READ_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ_WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    expected_hr = dynamic ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_WRITE_DISCARD, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_DISCARD.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    if (!dynamic)
+        return;
+
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_WRITE_NO_OVERWRITE, 0, &map_desc);
+    todo_wine
+    ok_(__FILE__, line)(hr == E_INVALIDARG, "Got hr %#x for WRITE_NO_OVERWRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+}
+
+static void test_resource_access(void)
+{
+    D3D10_TEXTURE2D_DESC texture_desc;
+    D3D10_BUFFER_DESC buffer_desc;
+    D3D10_SUBRESOURCE_DATA data;
+    BOOL cpu_write, cpu_read;
+    BOOL required_cpu_access;
+    ID3D10Texture2D *texture;
+    HRESULT hr, expected_hr;
+    BOOL broken_validation;
+    ID3D10Device *device;
+    ID3D10Buffer *buffer;
+    unsigned int i;
+    ULONG refcount;
+
+    static const struct
+    {
+        D3D10_USAGE usage;
+        UINT bind_flags;
+        BOOL is_valid;
+        UINT allowed_cpu_access;
+        UINT allowed_texture_cpu_access;
+    }
+    tests[] =
+    {
+        /* Default resources cannot be written by CPU. */
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_VERTEX_BUFFER,   TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_INDEX_BUFFER,    TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_CONSTANT_BUFFER, TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_SHADER_RESOURCE, TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_STREAM_OUTPUT,   TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_RENDER_TARGET,   TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_DEPTH_STENCIL,   TRUE, 0},
+
+        /* Immutable resources cannot be written by CPU and GPU. */
+        {D3D10_USAGE_IMMUTABLE, 0,                          FALSE, 0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_VERTEX_BUFFER,   TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_INDEX_BUFFER,    TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_CONSTANT_BUFFER, TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_SHADER_RESOURCE, TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_STREAM_OUTPUT,   FALSE, 0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_RENDER_TARGET,   FALSE, 0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_DEPTH_STENCIL,   FALSE, 0},
+
+        /* Dynamic resources cannot be written by GPU. */
+        {D3D10_USAGE_DYNAMIC, 0,                          FALSE, D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_VERTEX_BUFFER,   TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_INDEX_BUFFER,    TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_CONSTANT_BUFFER, TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_SHADER_RESOURCE, TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_STREAM_OUTPUT,   FALSE, D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_RENDER_TARGET,   FALSE, D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_DEPTH_STENCIL,   FALSE, D3D10_CPU_ACCESS_WRITE},
+
+        /* Staging resources support only data transfer. */
+        {D3D10_USAGE_STAGING, 0,                          TRUE,  D3D10_CPU_ACCESS_WRITE | D3D10_CPU_ACCESS_READ},
+        {D3D10_USAGE_STAGING, D3D10_BIND_VERTEX_BUFFER,   FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_INDEX_BUFFER,    FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_CONSTANT_BUFFER, FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_SHADER_RESOURCE, FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_STREAM_OUTPUT,   FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_RENDER_TARGET,   FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_DEPTH_STENCIL,   FALSE, 0},
+    };
+
+    if (!(device = create_device()))
+    {
+        skip("Failed to create device.\n");
+        return;
+    }
+
+    data.SysMemPitch = 0;
+    data.SysMemSlicePitch = 0;
+    data.pSysMem = HeapAlloc(GetProcessHeap(), 0, 10240);
+    ok(!!data.pSysMem, "Failed to allocate memory.\n");
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        if (tests[i].bind_flags == D3D10_BIND_DEPTH_STENCIL)
+            continue;
+
+        required_cpu_access = tests[i].usage == D3D10_USAGE_DYNAMIC || tests[i].usage == D3D10_USAGE_STAGING;
+        cpu_write = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_WRITE;
+        cpu_read = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_READ;
+
+        buffer_desc.ByteWidth = 1024;
+        buffer_desc.Usage = tests[i].usage;
+        buffer_desc.BindFlags = tests[i].bind_flags;
+        buffer_desc.MiscFlags = 0;
+
+        buffer_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE | D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+    }
+
+    data.SysMemPitch = 16;
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        if (tests[i].bind_flags == D3D10_BIND_VERTEX_BUFFER
+                || tests[i].bind_flags == D3D10_BIND_INDEX_BUFFER
+                || tests[i].bind_flags == D3D10_BIND_CONSTANT_BUFFER
+                || tests[i].bind_flags == D3D10_BIND_STREAM_OUTPUT)
+            continue;
+
+        broken_validation = tests[i].usage == D3D10_USAGE_DEFAULT
+                && (tests[i].bind_flags == D3D10_BIND_SHADER_RESOURCE
+                || tests[i].bind_flags == D3D10_BIND_RENDER_TARGET);
+
+        required_cpu_access = tests[i].usage == D3D10_USAGE_DYNAMIC || tests[i].usage == D3D10_USAGE_STAGING;
+        cpu_write = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_WRITE;
+        cpu_read = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_READ;
+
+        texture_desc.Width = 4;
+        texture_desc.Height = 4;
+        texture_desc.MipLevels = 1;
+        texture_desc.ArraySize = 1;
+        texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        texture_desc.SampleDesc.Count = 1;
+        texture_desc.SampleDesc.Quality = 0;
+        texture_desc.Usage = tests[i].usage;
+        texture_desc.BindFlags = tests[i].bind_flags;
+        texture_desc.MiscFlags = 0;
+        if (tests[i].bind_flags == D3D10_BIND_DEPTH_STENCIL)
+            texture_desc.Format = DXGI_FORMAT_D16_UNORM;
+
+        texture_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+
+        texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+
+        texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+
+        texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE | D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+    }
+
+    HeapFree(GetProcessHeap(), 0, (void *)data.pSysMem);
+
+    refcount = ID3D10Device_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+}
+
 static void test_check_multisample_quality_levels(void)
 {
     ID3D10Device *device;
@@ -13882,6 +14213,7 @@ START_TEST(device)
     test_fragment_coords();
     test_update_subresource();
     test_copy_subresource_region();
+    test_resource_access();
     test_check_multisample_quality_levels();
     test_cb_relative_addressing();
     test_vs_input_relative_addressing();
-- 
2.13.6

[PATCH v2 4/4] d3d10core/tests: Add test for resource access flags.

[Józef Kucia]

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com>
---

Version 2: Remove allowed_texture_cpu_access.

---
 dlls/d3d10core/tests/device.c | 331 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 331 insertions(+)

diff --git a/dlls/d3d10core/tests/device.c b/dlls/d3d10core/tests/device.c
index 86a8f43d4e93..351f1261000a 100644
--- a/dlls/d3d10core/tests/device.c
+++ b/dlls/d3d10core/tests/device.c
@@ -8186,6 +8186,336 @@ static void test_copy_subresource_region(void)
     release_test_context(&test_context);
 }
 
+#define check_buffer_cpu_access(a, b, c, d) check_buffer_cpu_access_(__LINE__, a, b, c, d)
+static void check_buffer_cpu_access_(unsigned int line, ID3D10Buffer *buffer,
+        D3D10_USAGE usage, UINT bind_flags, UINT cpu_access)
+{
+    BOOL cpu_write = cpu_access & D3D10_CPU_ACCESS_WRITE;
+    BOOL cpu_read = cpu_access & D3D10_CPU_ACCESS_READ;
+    BOOL dynamic = usage == D3D10_USAGE_DYNAMIC;
+    HRESULT hr, expected_hr;
+    ID3D10Device *device;
+    void *data;
+
+    expected_hr = cpu_read ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_READ, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    expected_hr = !dynamic && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_WRITE, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    expected_hr = cpu_read && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_READ_WRITE, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ_WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    expected_hr = dynamic ? S_OK : E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_WRITE_DISCARD, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_DISCARD.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    if (!dynamic)
+        return;
+
+    ID3D10Buffer_GetDevice(buffer, &device);
+
+    expected_hr = S_OK;
+    if (bind_flags & (D3D10_BIND_CONSTANT_BUFFER | D3D10_BIND_SHADER_RESOURCE)
+            && !is_d3d11_interface_available(device))
+        expected_hr = E_INVALIDARG;
+    hr = ID3D10Buffer_Map(buffer, D3D10_MAP_WRITE_NO_OVERWRITE, 0, &data);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_NO_OVERWRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Buffer_Unmap(buffer);
+
+    ID3D10Device_Release(device);
+}
+
+#define check_texture_cpu_access(a, b, c, d) check_texture_cpu_access_(__LINE__, a, b, c, d)
+static void check_texture_cpu_access_(unsigned int line, ID3D10Texture2D *texture,
+        D3D10_USAGE usage, UINT bind_flags, UINT cpu_access)
+{
+    BOOL cpu_write = cpu_access & D3D10_CPU_ACCESS_WRITE;
+    BOOL cpu_read = cpu_access & D3D10_CPU_ACCESS_READ;
+    BOOL dynamic = usage == D3D10_USAGE_DYNAMIC;
+    D3D10_MAPPED_TEXTURE2D map_desc;
+    HRESULT hr, expected_hr;
+
+    expected_hr = cpu_read ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_READ, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    expected_hr = !dynamic && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    expected_hr = cpu_read && cpu_write ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_READ_WRITE, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for READ_WRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    expected_hr = dynamic ? S_OK : E_INVALIDARG;
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_WRITE_DISCARD, 0, &map_desc);
+    todo_wine_if(expected_hr != S_OK)
+    ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x for WRITE_DISCARD.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+
+    if (!dynamic)
+        return;
+
+    hr = ID3D10Texture2D_Map(texture, 0, D3D10_MAP_WRITE_NO_OVERWRITE, 0, &map_desc);
+    todo_wine
+    ok_(__FILE__, line)(hr == E_INVALIDARG, "Got hr %#x for WRITE_NO_OVERWRITE.\n", hr);
+    if (SUCCEEDED(hr))
+        ID3D10Texture2D_Unmap(texture, 0);
+}
+
+static void test_resource_access(void)
+{
+    D3D10_TEXTURE2D_DESC texture_desc;
+    D3D10_BUFFER_DESC buffer_desc;
+    D3D10_SUBRESOURCE_DATA data;
+    BOOL cpu_write, cpu_read;
+    BOOL required_cpu_access;
+    ID3D10Texture2D *texture;
+    HRESULT hr, expected_hr;
+    BOOL broken_validation;
+    ID3D10Device *device;
+    ID3D10Buffer *buffer;
+    unsigned int i;
+    ULONG refcount;
+
+    static const struct
+    {
+        D3D10_USAGE usage;
+        UINT bind_flags;
+        BOOL is_valid;
+        UINT allowed_cpu_access;
+    }
+    tests[] =
+    {
+        /* Default resources cannot be written by CPU. */
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_VERTEX_BUFFER,   TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_INDEX_BUFFER,    TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_CONSTANT_BUFFER, TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_SHADER_RESOURCE, TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_STREAM_OUTPUT,   TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_RENDER_TARGET,   TRUE, 0},
+        {D3D10_USAGE_DEFAULT, D3D10_BIND_DEPTH_STENCIL,   TRUE, 0},
+
+        /* Immutable resources cannot be written by CPU and GPU. */
+        {D3D10_USAGE_IMMUTABLE, 0,                          FALSE, 0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_VERTEX_BUFFER,   TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_INDEX_BUFFER,    TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_CONSTANT_BUFFER, TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_SHADER_RESOURCE, TRUE,  0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_STREAM_OUTPUT,   FALSE, 0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_RENDER_TARGET,   FALSE, 0},
+        {D3D10_USAGE_IMMUTABLE, D3D10_BIND_DEPTH_STENCIL,   FALSE, 0},
+
+        /* Dynamic resources cannot be written by GPU. */
+        {D3D10_USAGE_DYNAMIC, 0,                          FALSE, D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_VERTEX_BUFFER,   TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_INDEX_BUFFER,    TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_CONSTANT_BUFFER, TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_SHADER_RESOURCE, TRUE,  D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_STREAM_OUTPUT,   FALSE, D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_RENDER_TARGET,   FALSE, D3D10_CPU_ACCESS_WRITE},
+        {D3D10_USAGE_DYNAMIC, D3D10_BIND_DEPTH_STENCIL,   FALSE, D3D10_CPU_ACCESS_WRITE},
+
+        /* Staging resources support only data transfer. */
+        {D3D10_USAGE_STAGING, 0,                          TRUE,  D3D10_CPU_ACCESS_WRITE | D3D10_CPU_ACCESS_READ},
+        {D3D10_USAGE_STAGING, D3D10_BIND_VERTEX_BUFFER,   FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_INDEX_BUFFER,    FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_CONSTANT_BUFFER, FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_SHADER_RESOURCE, FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_STREAM_OUTPUT,   FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_RENDER_TARGET,   FALSE, 0},
+        {D3D10_USAGE_STAGING, D3D10_BIND_DEPTH_STENCIL,   FALSE, 0},
+    };
+
+    if (!(device = create_device()))
+    {
+        skip("Failed to create device.\n");
+        return;
+    }
+
+    data.SysMemPitch = 0;
+    data.SysMemSlicePitch = 0;
+    data.pSysMem = HeapAlloc(GetProcessHeap(), 0, 10240);
+    ok(!!data.pSysMem, "Failed to allocate memory.\n");
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        if (tests[i].bind_flags == D3D10_BIND_DEPTH_STENCIL)
+            continue;
+
+        required_cpu_access = tests[i].usage == D3D10_USAGE_DYNAMIC || tests[i].usage == D3D10_USAGE_STAGING;
+        cpu_write = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_WRITE;
+        cpu_read = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_READ;
+
+        buffer_desc.ByteWidth = 1024;
+        buffer_desc.Usage = tests[i].usage;
+        buffer_desc.BindFlags = tests[i].bind_flags;
+        buffer_desc.MiscFlags = 0;
+
+        buffer_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+
+        buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE | D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &data, &buffer);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_buffer_cpu_access(buffer, buffer_desc.Usage,
+                    buffer_desc.BindFlags, buffer_desc.CPUAccessFlags);
+            ID3D10Buffer_Release(buffer);
+        }
+    }
+
+    data.SysMemPitch = 16;
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i)
+    {
+        if (tests[i].bind_flags == D3D10_BIND_VERTEX_BUFFER
+                || tests[i].bind_flags == D3D10_BIND_INDEX_BUFFER
+                || tests[i].bind_flags == D3D10_BIND_CONSTANT_BUFFER
+                || tests[i].bind_flags == D3D10_BIND_STREAM_OUTPUT)
+            continue;
+
+        broken_validation = tests[i].usage == D3D10_USAGE_DEFAULT
+                && (tests[i].bind_flags == D3D10_BIND_SHADER_RESOURCE
+                || tests[i].bind_flags == D3D10_BIND_RENDER_TARGET);
+
+        required_cpu_access = tests[i].usage == D3D10_USAGE_DYNAMIC || tests[i].usage == D3D10_USAGE_STAGING;
+        cpu_write = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_WRITE;
+        cpu_read = tests[i].allowed_cpu_access & D3D10_CPU_ACCESS_READ;
+
+        texture_desc.Width = 4;
+        texture_desc.Height = 4;
+        texture_desc.MipLevels = 1;
+        texture_desc.ArraySize = 1;
+        texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        texture_desc.SampleDesc.Count = 1;
+        texture_desc.SampleDesc.Quality = 0;
+        texture_desc.Usage = tests[i].usage;
+        texture_desc.BindFlags = tests[i].bind_flags;
+        texture_desc.MiscFlags = 0;
+        if (tests[i].bind_flags == D3D10_BIND_DEPTH_STENCIL)
+            texture_desc.Format = DXGI_FORMAT_D16_UNORM;
+
+        texture_desc.CPUAccessFlags = 0;
+        expected_hr = tests[i].is_valid && !required_cpu_access ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr, "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+
+        texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
+        expected_hr = tests[i].is_valid && cpu_write ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+
+        texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+
+        texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE | D3D10_CPU_ACCESS_READ;
+        expected_hr = tests[i].is_valid && cpu_write && cpu_read ? S_OK : E_INVALIDARG;
+        hr = ID3D10Device_CreateTexture2D(device, &texture_desc, &data, &texture);
+        ok(hr == expected_hr || (hr == S_OK && broken_validation),
+                "Got hr %#x, expected %#x, test %u.\n", hr, expected_hr, i);
+        if (SUCCEEDED(hr))
+        {
+            if (broken_validation)
+                texture_desc.CPUAccessFlags = 0;
+            check_texture_cpu_access(texture, texture_desc.Usage,
+                    texture_desc.BindFlags, texture_desc.CPUAccessFlags);
+            ID3D10Texture2D_Release(texture);
+        }
+    }
+
+    HeapFree(GetProcessHeap(), 0, (void *)data.pSysMem);
+
+    refcount = ID3D10Device_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+}
+
 static void test_check_multisample_quality_levels(void)
 {
     ID3D10Device *device;
@@ -13882,6 +14212,7 @@ START_TEST(device)
     test_fragment_coords();
     test_update_subresource();
     test_copy_subresource_region();
+    test_resource_access();
     test_check_multisample_quality_levels();
     test_cb_relative_addressing();
     test_vs_input_relative_addressing();
-- 
2.13.6

[Henri Verbeet]

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com>