blob.c File Reference

#include "d3dcompiler.h"
#include "wine/test.h"

Include dependency graph for blob.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	D3DERR_INVALIDCALL   0x8876086c
#define	MAKE_TAG(ch0, ch1, ch2, ch3)
#define	TAG_Aon9   MAKE_TAG('A', 'o', 'n', '9')
#define	TAG_DXBC   MAKE_TAG('D', 'X', 'B', 'C')
#define	TAG_ISGN   MAKE_TAG('I', 'S', 'G', 'N')
#define	TAG_OSGN   MAKE_TAG('O', 'S', 'G', 'N')
#define	TAG_PCSG   MAKE_TAG('P', 'C', 'S', 'G')
#define	TAG_RDEF   MAKE_TAG('R', 'D', 'E', 'F')
#define	TAG_SDBG   MAKE_TAG('S', 'D', 'B', 'G')
#define	TAG_SHDR   MAKE_TAG('S', 'H', 'D', 'R')
#define	TAG_SHEX   MAKE_TAG('S', 'H', 'E', 'X')
#define	TAG_STAT   MAKE_TAG('S', 'T', 'A', 'T')
#define	TAG_XNAP   MAKE_TAG('X', 'N', 'A', 'P')
#define	TAG_XNAS   MAKE_TAG('X', 'N', 'A', 'S')

Functions
static	HRESULT (WINAPI *pD3DCreateBlob)(SIZE_T
static void	test_create_blob (void)
static void	test_get_blob_part (void)
static void	test_get_blob_part2 (void)
static BOOL	load_d3dcompiler_43 (void)
static BOOL	load_d3dcompiler_47 (void)
static BOOL	create_file (WCHAR *filename, const DWORD *data, DWORD data_size)
static void	test_D3DReadFileToBlob (void)
	START_TEST (blob)

Variables
static ID3DBlob **static	SIZE_T
static ID3DBlob **static	D3D_BLOB_PART
static ID3DBlob **static	UINT
static const D3D_BLOB_PART	parts []
static DWORD	test_blob_part []
static DWORD	test_blob_part2 []
static const DWORD	test_cso_data []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file blob.c.

D3DERR_INVALIDCALL

#define D3DERR_INVALIDCALL   0x8876086c

Definition at line 34 of file blob.c.

MAKE_TAG

#define MAKE_TAG	(		ch0,
			ch1,
			ch2,
			ch3
	)

Value:

    ((DWORD)(ch0) | ((DWORD)(ch1) << 8) | \
    ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 ))

Definition at line 41 of file blob.c.

TAG_Aon9

#define TAG_Aon9   MAKE_TAG('A', 'o', 'n', '9')

Definition at line 44 of file blob.c.

TAG_DXBC

#define TAG_DXBC   MAKE_TAG('D', 'X', 'B', 'C')

Definition at line 45 of file blob.c.

TAG_ISGN

#define TAG_ISGN   MAKE_TAG('I', 'S', 'G', 'N')

Definition at line 46 of file blob.c.

TAG_OSGN

#define TAG_OSGN   MAKE_TAG('O', 'S', 'G', 'N')

Definition at line 47 of file blob.c.

TAG_PCSG

#define TAG_PCSG   MAKE_TAG('P', 'C', 'S', 'G')

Definition at line 48 of file blob.c.

TAG_RDEF

#define TAG_RDEF   MAKE_TAG('R', 'D', 'E', 'F')

Definition at line 49 of file blob.c.

TAG_SDBG

#define TAG_SDBG   MAKE_TAG('S', 'D', 'B', 'G')

Definition at line 50 of file blob.c.

TAG_SHDR

#define TAG_SHDR   MAKE_TAG('S', 'H', 'D', 'R')

Definition at line 51 of file blob.c.

TAG_SHEX

#define TAG_SHEX   MAKE_TAG('S', 'H', 'E', 'X')

Definition at line 52 of file blob.c.

TAG_STAT

#define TAG_STAT   MAKE_TAG('S', 'T', 'A', 'T')

Definition at line 53 of file blob.c.

TAG_XNAP

#define TAG_XNAP   MAKE_TAG('X', 'N', 'A', 'P')

Definition at line 54 of file blob.c.

TAG_XNAS

#define TAG_XNAS   MAKE_TAG('X', 'N', 'A', 'S')

Definition at line 55 of file blob.c.

Function Documentation

create_file()

static BOOL create_file ( WCHAR *  filename, const DWORD *  data, DWORD  data_size  )

static

Definition at line 767 of file blob.c.

{
    static WCHAR temp_dir[MAX_PATH];
    DWORD written;
    HANDLE file;
 
    if (!temp_dir[0])
        GetTempPathW(ARRAY_SIZE(temp_dir), temp_dir);
    GetTempFileNameW(temp_dir, NULL, 0, filename);
    file = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
    if (file == INVALID_HANDLE_VALUE)
        return FALSE;
 
    if (data)
    {
        WriteFile(file, data, data_size, &written, NULL);
        if (written != data_size)
        {
            CloseHandle(file);
            DeleteFileW(filename);
            return FALSE;
        }
    }
    CloseHandle(file);
    return TRUE;
}

HRESULT()

static HRESULT ( WINAPI *  pD3DCreateBlob )

static

load_d3dcompiler_43()

static BOOL load_d3dcompiler_43 ( void  )

static

Definition at line 744 of file blob.c.

{
    HMODULE module;
 
    if (!(module = LoadLibraryA("d3dcompiler_43.dll"))) return FALSE;
 
    pD3DCreateBlob = (void*)GetProcAddress(module, "D3DCreateBlob");
    pD3DGetBlobPart = (void*)GetProcAddress(module, "D3DGetBlobPart");
    pD3DStripShader = (void*)GetProcAddress(module, "D3DStripShader");
    return TRUE;
}

Referenced by START_TEST().

load_d3dcompiler_47()

static BOOL load_d3dcompiler_47 ( void  )

static

Definition at line 756 of file blob.c.

{
    HMODULE module;
 
    if (!(module = LoadLibraryA("d3dcompiler_47.dll")))
        return FALSE;
 
    pD3DReadFileToBlob = (void *)GetProcAddress(module, "D3DReadFileToBlob");
    return TRUE;
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

blob

)

Definition at line 865 of file blob.c.

{
    if (load_d3dcompiler_43())
    {
        test_create_blob();
        test_get_blob_part();
        test_get_blob_part2();
    }
    else
    {
        win_skip("Could not load d3dcompiler_43.dll\n");
    }
 
    if (load_d3dcompiler_47())
    {
        test_D3DReadFileToBlob();
    }
    else
    {
        win_skip("Could not load d3dcompiler_47.dll.\n");
    }
}

test_create_blob()

static void test_create_blob ( void  )

static

Definition at line 57 of file blob.c.

{
    ID3D10Blob *blob;
    HRESULT hr;
    ULONG refcount;
 
    hr = pD3DCreateBlob(1, NULL);
    ok(hr == D3DERR_INVALIDCALL, "D3DCreateBlob failed with %x\n", hr);
 
    hr = pD3DCreateBlob(0, NULL);
    ok(hr == D3DERR_INVALIDCALL, "D3DCreateBlob failed with %x\n", hr);
 
    hr = pD3DCreateBlob(0, &blob);
    ok(hr == S_OK, "D3DCreateBlob failed with %x\n", hr);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
}

Referenced by START_TEST().

test_D3DReadFileToBlob()

static void test_D3DReadFileToBlob ( void  )

static

Definition at line 816 of file blob.c.

{
    WCHAR filename[MAX_PATH] = {'n','o','n','e','x','i','s','t','e','n','t',0};
    ID3DBlob *blob = NULL;
    SIZE_T data_size;
    DWORD *data;
    HRESULT hr;
 
    hr = pD3DReadFileToBlob(filename, NULL);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "Got unexpected hr %#x.\n", hr);
 
    hr = pD3DReadFileToBlob(filename, &blob);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "Got unexpected hr %#x.\n", hr);
 
    if (0)
    {
        /* Crashes on Windows. */
        create_file(filename, test_cso_data, ARRAY_SIZE(test_cso_data));
        pD3DReadFileToBlob(filename, NULL);
        DeleteFileW(filename);
    }
 
    if (!create_file(filename, NULL, 0))
    {
        win_skip("File creation failed.\n");
        return;
    }
    hr = pD3DReadFileToBlob(filename, &blob);
    ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
    data_size = ID3D10Blob_GetBufferSize(blob);
    ok(!data_size, "Got unexpected data size.\n");
    DeleteFileW(filename);
    ID3D10Blob_Release(blob);
 
    if (!create_file(filename, test_cso_data, ARRAY_SIZE(test_cso_data)))
    {
        win_skip("File creation failed.\n");
        return;
    }
    hr = pD3DReadFileToBlob(filename, &blob);
    ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
    data_size = ID3D10Blob_GetBufferSize(blob);
    ok(data_size == ARRAY_SIZE(test_cso_data), "Got unexpected data size.\n");
    data = ID3D10Blob_GetBufferPointer(blob);
    ok(!memcmp(data, test_cso_data, ARRAY_SIZE(test_cso_data)), "Got unexpected data.\n");
    DeleteFileW(filename);
    ID3D10Blob_Release(blob);
}

Referenced by START_TEST().

test_get_blob_part()

static void test_get_blob_part ( void  )

static

Definition at line 119 of file blob.c.

{
    ID3DBlob *blob, *blob2;
    HRESULT hr;
    ULONG refcount;
    DWORD *dword;
    SIZE_T size;
    UINT i;
 
    hr = pD3DCreateBlob(1, &blob2);
    ok(hr == S_OK, "D3DCreateBlob failed with %x\n", hr);
    blob = blob2;
 
    /* invalid cases */
    hr = pD3DGetBlobPart(NULL, test_blob_part[6], D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
    ok(blob2 == blob, "D3DGetBlobPart failed got %p, expected %p\n", blob, blob2);
 
    hr = pD3DGetBlobPart(NULL, 0, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
    ok(blob2 == blob, "D3DGetBlobPart failed got %p, expected %p\n", blob, blob2);
 
    hr = pD3DGetBlobPart(NULL, test_blob_part[6], D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, NULL);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
 
    hr = pD3DGetBlobPart(NULL, 0, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, NULL);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
 
    hr = pD3DGetBlobPart(test_blob_part, 0, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
    ok(blob2 == blob, "D3DGetBlobPart failed got %p, expected %p\n", blob, blob2);
 
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, NULL);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
 
    hr = pD3DGetBlobPart(test_blob_part, 0, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, NULL);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
 
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_INPUT_SIGNATURE_BLOB, 1, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
    ok(blob2 == blob, "D3DGetBlobPart failed got %p, expected %p\n", blob, blob2);
 
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], 0xffffffff, 0, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DGetBlobPart failed with %x\n", hr);
    ok(blob2 == blob, "D3DGetBlobPart failed got %p, expected %p\n", blob, blob2);
 
    refcount = ID3D10Blob_Release(blob2);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_INPUT_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 124, "GetBufferSize failed, got %lu, expected %u\n", size, 124);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_ISGN == *(dword+9), "ISGN got %#x, expected %#x.\n", *(dword+9), TAG_ISGN);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
 
        if (parts[i] == D3D_BLOB_INPUT_SIGNATURE_BLOB)
        {
            ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
            refcount = ID3D10Blob_Release(blob2);
            ok(!refcount, "ID3DBlob has %u references left\n", refcount);
        }
        else
        {
            ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
        }
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_OUTPUT_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_OUTPUT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 88, "GetBufferSize failed, got %lu, expected %u\n", size, 88);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_OSGN == *(dword+9), "OSGN got %#x, expected %#x.\n", *(dword+9), TAG_OSGN);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
 
        if (parts[i] == D3D_BLOB_OUTPUT_SIGNATURE_BLOB)
        {
            ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
            refcount = ID3D10Blob_Release(blob2);
            ok(!refcount, "ID3DBlob has %u references left\n", refcount);
        }
        else
        {
            ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
        }
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 180, "GetBufferSize failed, got %lu, expected %u\n", size, 180);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_ISGN == *(dword+10), "ISGN got %#x, expected %#x.\n", *(dword+10), TAG_ISGN);
    ok(TAG_OSGN == *(dword+32), "OSGN got %#x, expected %#x.\n", *(dword+32), TAG_OSGN);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
 
        if (parts[i] == D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB
                || parts[i] == D3D_BLOB_INPUT_SIGNATURE_BLOB
                || parts[i] == D3D_BLOB_OUTPUT_SIGNATURE_BLOB)
        {
            ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
            refcount = ID3D10Blob_Release(blob2);
            ok(!refcount, "ID3DBlob has %u references left\n", refcount);
        }
        else
        {
            ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
        }
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3D_BLOB_ALL_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_ALL_SIGNATURE_BLOB, 0, &blob);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3D_BLOB_DEBUG_INFO */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_DEBUG_INFO, 0, &blob);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3D_BLOB_LEGACY_SHADER */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_LEGACY_SHADER, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 92, "GetBufferSize failed, got %lu, expected %u\n", size, 92);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(test_blob_part[0] != *dword, "DXBC failed got %#x.\n", *dword);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        /* There isn't a full DXBC blob returned for D3D_BLOB_LEGACY_SHADER */
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
        ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_XNA_PREPASS_SHADER */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_XNA_PREPASS_SHADER, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 68, "GetBufferSize failed, got %lu, expected %u\n", size, 68);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(test_blob_part[0] != *dword, "DXBC failed got %#x.\n", *dword);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        /* There isn't a full DXBC blob returned for D3D_BLOB_XNA_PREPASS_SHADER */
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
        ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_XNA_SHADER */
    hr = pD3DGetBlobPart(test_blob_part, test_blob_part[6], D3D_BLOB_XNA_SHADER, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 68, "GetBufferSize failed, got %lu, expected %u\n", size, 68);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(test_blob_part[0] != *dword, "DXBC failed got %#x.\n", *dword);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        /* There isn't a full DXBC blob returned for D3D_BLOB_XNA_SHADER */
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
        ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* check corner cases for D3DStripShader */
    hr = pD3DStripShader(test_blob_part, test_blob_part[6], 0xffffffff, &blob);
    ok(hr == S_OK, "D3DStripShader failed, got %x, expected %x\n", hr, S_OK);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    hr = pD3DStripShader(test_blob_part, test_blob_part[6], 0, &blob);
    ok(hr == S_OK, "D3DStripShader failed, got %x, expected %x\n", hr, S_OK);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    hr = pD3DStripShader(NULL, test_blob_part[6], 0, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DStripShader failed, got %x, expected %x\n", hr, D3DERR_INVALIDCALL);
 
    hr = pD3DStripShader(test_blob_part, 2, 0, &blob);
    ok(hr == D3DERR_INVALIDCALL, "D3DStripShader failed, got %x, expected %x\n", hr, D3DERR_INVALIDCALL);
 
    hr = pD3DStripShader(test_blob_part, test_blob_part[6], 0, NULL);
    ok(hr == E_FAIL, "D3DStripShader failed, got %x, expected %x\n", hr, E_FAIL);
 
    hr = pD3DStripShader(NULL, test_blob_part[6], 0, NULL);
    ok(hr == E_FAIL, "D3DStripShader failed, got %x, expected %x\n", hr, E_FAIL);
 
    hr = pD3DStripShader(test_blob_part, 0, 0, NULL);
    ok(hr == E_FAIL, "D3DStripShader failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3DCOMPILER_STRIP_DEBUG_INFO */
    hr = pD3DStripShader(test_blob_part, test_blob_part[6], D3DCOMPILER_STRIP_DEBUG_INFO, &blob);
    ok(hr == S_OK, "D3DStripShader failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 736, "GetBufferSize failed, got %lu, expected %u\n", size, 736);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_XNAS == *(dword+16), "XNAS got %#x, expected %#x.\n", *(dword+16), TAG_XNAS);
    ok(TAG_XNAP == *(dword+35), "XNAP got %#x, expected %#x.\n", *(dword+35), TAG_XNAP);
    ok(TAG_Aon9 == *(dword+54), "Aon9 got %#x, expected %#x.\n", *(dword+54), TAG_Aon9);
    ok(TAG_SHDR == *(dword+79), "SHDR got %#x, expected %#x.\n", *(dword+79), TAG_SHDR);
    ok(TAG_STAT == *(dword+96), "STAT got %#x, expected %#x.\n", *(dword+96), TAG_STAT);
    ok(TAG_RDEF == *(dword+127), "RDEF got %#x, expected %#x.\n", *(dword+127), TAG_RDEF);
    ok(TAG_ISGN == *(dword+149), "ISGN got %#x, expected %#x.\n", *(dword+149), TAG_ISGN);
    ok(TAG_OSGN == *(dword+171), "OSGN got %#x, expected %#x.\n", *(dword+171), TAG_OSGN);
 
    hr = pD3DGetBlobPart(dword, size, D3D_BLOB_DEBUG_INFO, 0, &blob2);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3DCOMPILER_STRIP_REFLECTION_DATA */
    hr = pD3DStripShader(test_blob_part, test_blob_part[6], D3DCOMPILER_STRIP_REFLECTION_DATA, &blob);
    ok(hr == S_OK, "D3DStripShader failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 516, "GetBufferSize failed, got %lu, expected %u\n", size, 516);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_XNAS == *(dword+14), "XNAS got %#x, expected %#x.\n", *(dword+14), TAG_XNAS);
    ok(TAG_XNAP == *(dword+33), "XNAP got %#x, expected %#x.\n", *(dword+33), TAG_XNAP);
    ok(TAG_Aon9 == *(dword+52), "Aon9 got %#x, expected %#x.\n", *(dword+52), TAG_Aon9);
    ok(TAG_SHDR == *(dword+77), "SHDR got %#x, expected %#x.\n", *(dword+77), TAG_SHDR);
    ok(TAG_ISGN == *(dword+94), "ISGN got %#x, expected %#x.\n", *(dword+94), TAG_ISGN);
    ok(TAG_OSGN == *(dword+116), "OSGN got %#x, expected %#x.\n", *(dword+116), TAG_OSGN);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
}

Referenced by START_TEST().

test_get_blob_part2()

static void test_get_blob_part2 ( void  )

static

Definition at line 594 of file blob.c.

{
    ID3DBlob *blob, *blob2;
    HRESULT hr;
    ULONG refcount;
    DWORD *dword;
    SIZE_T size;
    UINT i;
 
    /* D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part2, test_blob_part2[6], D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 232, "GetBufferSize failed, got %lu, expected %u\n", size, 232);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_PCSG == *(dword+9), "PCSG got %#x, expected %#x.\n", *(dword+9), TAG_PCSG);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
 
        if (parts[i] == D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB)
        {
            ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
            refcount = ID3D10Blob_Release(blob2);
            ok(!refcount, "ID3DBlob has %u references left\n", refcount);
        }
        else
        {
            ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
        }
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_ALL_SIGNATURE_BLOB */
    hr = pD3DGetBlobPart(test_blob_part2, test_blob_part2[6], D3D_BLOB_ALL_SIGNATURE_BLOB, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 344, "GetBufferSize failed, got %lu, expected %u\n", size, 344);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_ISGN == *(dword+11), "ISGN got %#x, expected %#x.\n", *(dword+11), TAG_ISGN);
    ok(TAG_OSGN == *(dword+24), "OSGN got %#x, expected %#x.\n", *(dword+24), TAG_OSGN);
    ok(TAG_PCSG == *(dword+37), "PCSG got %#x, expected %#x.\n", *(dword+37), TAG_PCSG);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
 
        if (parts[i] == D3D_BLOB_ALL_SIGNATURE_BLOB
                || parts[i] == D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB
                || parts[i] == D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB
                || parts[i] == D3D_BLOB_INPUT_SIGNATURE_BLOB
                || parts[i] == D3D_BLOB_OUTPUT_SIGNATURE_BLOB)
        {
            ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
            refcount = ID3D10Blob_Release(blob2);
            ok(!refcount, "ID3DBlob has %u references left\n", refcount);
        }
        else
        {
            ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
        }
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_DEBUG_INFO */
    hr = pD3DGetBlobPart(test_blob_part2, test_blob_part2[6], D3D_BLOB_DEBUG_INFO, 0, &blob);
    ok(hr == S_OK, "D3DGetBlobPart failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 4055, "GetBufferSize failed, got %lu, expected %u\n", size, 4055);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC != *dword, "DXBC failed got %#x.\n", *dword);
 
    for (i = 0; i < ARRAY_SIZE(parts); i++)
    {
        /* There isn't a full DXBC blob returned for D3D_BLOB_DEBUG_INFO */
        hr = pD3DGetBlobPart(dword, size, parts[i], 0, &blob2);
        ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
    }
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3D_BLOB_LEGACY_SHADER */
    hr = pD3DGetBlobPart(test_blob_part2, test_blob_part2[6], D3D_BLOB_LEGACY_SHADER, 0, &blob);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3D_BLOB_XNA_PREPASS_SHADER */
    hr = pD3DGetBlobPart(test_blob_part2, test_blob_part2[6], D3D_BLOB_XNA_PREPASS_SHADER, 0, &blob);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3D_BLOB_XNA_SHADER */
    hr = pD3DGetBlobPart(test_blob_part2, test_blob_part2[6], D3D_BLOB_XNA_SHADER, 0, &blob);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    /* D3DCOMPILER_STRIP_DEBUG_INFO */
    hr = pD3DStripShader(test_blob_part2, test_blob_part2[6], D3DCOMPILER_STRIP_DEBUG_INFO, &blob);
    ok(hr == S_OK, "D3DStripShader failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 952, "GetBufferSize failed, got %lu, expected %u\n", size, 952);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_RDEF == *(dword+14), "RDEF got %#x, expected %#x.\n", *(dword+14), TAG_RDEF);
    ok(TAG_ISGN == *(dword+44), "ISGN got %#x, expected %#x.\n", *(dword+44), TAG_ISGN);
    ok(TAG_OSGN == *(dword+57), "OSGN got %#x, expected %#x.\n", *(dword+57), TAG_OSGN);
    ok(TAG_PCSG == *(dword+70), "PCSG got %#x, expected %#x.\n", *(dword+70), TAG_PCSG);
    ok(TAG_SHEX == *(dword+119), "SHEX got %#x, expected %#x.\n", *(dword+119), TAG_SHEX);
    ok(TAG_STAT == *(dword+199), "STAT got %#x, expected %#x.\n", *(dword+199), TAG_STAT);
 
    hr = pD3DGetBlobPart(dword, size, D3D_BLOB_DEBUG_INFO, 0, &blob2);
    ok(hr == E_FAIL, "D3DGetBlobPart failed, got %x, expected %x\n", hr, E_FAIL);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
 
    /* D3DCOMPILER_STRIP_REFLECTION_DATA */
    hr = pD3DStripShader(test_blob_part2, test_blob_part2[6], D3DCOMPILER_STRIP_REFLECTION_DATA, &blob);
    ok(hr == S_OK, "D3DStripShader failed, got %x, expected %x\n", hr, S_OK);
 
    size = ID3D10Blob_GetBufferSize(blob);
    ok(size == 4735, "GetBufferSize failed, got %lu, expected %u\n", size, 4735);
 
    dword = ((DWORD*)ID3D10Blob_GetBufferPointer(blob));
    ok(TAG_DXBC == *dword, "DXBC got %#x, expected %#x.\n", *dword, TAG_DXBC);
    ok(TAG_ISGN == *(dword+13), "ISGN got %#x, expected %#x.\n", *(dword+13), TAG_ISGN);
    ok(TAG_OSGN == *(dword+26), "OSGN got %#x, expected %#x.\n", *(dword+26), TAG_OSGN);
    ok(TAG_PCSG == *(dword+39), "PCSG got %#x, expected %#x.\n", *(dword+39), TAG_PCSG);
    ok(TAG_SHEX == *(dword+88), "SHEX got %#x, expected %#x.\n", *(dword+88), TAG_SHEX);
    ok(TAG_SDBG == *(dword+168), "SDBG got %#x, expected %#x.\n", *(dword+168), TAG_SDBG);
 
    refcount = ID3D10Blob_Release(blob);
    ok(!refcount, "ID3DBlob has %u references left\n", refcount);
}

Referenced by START_TEST().

Variable Documentation

D3D_BLOB_PART

ID3DBlob **static D3D_BLOB_PART

Definition at line 37 of file blob.c.

parts

const D3D_BLOB_PART parts[]

static

Initial value:

=
{
   D3D_BLOB_INPUT_SIGNATURE_BLOB, D3D_BLOB_OUTPUT_SIGNATURE_BLOB, D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB,
   D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB, D3D_BLOB_ALL_SIGNATURE_BLOB, D3D_BLOB_DEBUG_INFO,
   D3D_BLOB_LEGACY_SHADER, D3D_BLOB_XNA_PREPASS_SHADER, D3D_BLOB_XNA_SHADER,
   D3D_BLOB_TEST_ALTERNATE_SHADER, D3D_BLOB_TEST_COMPILE_DETAILS, D3D_BLOB_TEST_COMPILE_PERF
}

Definition at line 76 of file blob.c.

Referenced by test_get_blob_part(), and test_get_blob_part2().

SIZE_T

ID3DBlob **static ID3DBlob **static ID3DBlob **static SIZE_T

Definition at line 37 of file blob.c.

test_blob_part

DWORD test_blob_part[]

static

Initial value:

= {
0x43425844, 0x0ef2a70f, 0x6a548011, 0x91ff9409, 0x9973a43d, 0x00000001, 0x000002e0, 0x00000008,
0x00000040, 0x0000008c, 0x000000d8, 0x0000013c, 0x00000180, 0x000001fc, 0x00000254, 0x000002ac,
0x53414e58, 0x00000044, 0x00000044, 0xfffe0200, 0x00000020, 0x00000024, 0x00240000, 0x00240000,
0x00240000, 0x00240000, 0x00240000, 0xfffe0200, 0x0200001f, 0x80000005, 0x900f0000, 0x02000001,
0xc00f0000, 0x80e40000, 0x0000ffff, 0x50414e58, 0x00000044, 0x00000044, 0xfffe0200, 0x00000020,
0x00000024, 0x00240000, 0x00240000, 0x00240000, 0x00240000, 0x00240000, 0xfffe0200, 0x0200001f,
0x80000005, 0x900f0000, 0x02000001, 0xc00f0000, 0x80e40000, 0x0000ffff, 0x396e6f41, 0x0000005c,
0x0000005c, 0xfffe0200, 0x00000034, 0x00000028, 0x00240000, 0x00240000, 0x00240000, 0x00240000,
0x00240001, 0x00000000, 0xfffe0200, 0x0200001f, 0x80000005, 0x900f0000, 0x04000004, 0xc0030000,
0x90ff0000, 0xa0e40000, 0x90e40000, 0x02000001, 0xc00c0000, 0x90e40000, 0x0000ffff, 0x52444853,
0x0000003c, 0x00010040, 0x0000000f, 0x0300005f, 0x001010f2, 0x00000000, 0x04000067, 0x001020f2,
0x00000000, 0x00000001, 0x05000036, 0x001020f2, 0x00000000, 0x00101e46, 0x00000000, 0x0100003e,
0x54415453, 0x00000074, 0x00000002, 0x00000000, 0x00000000, 0x00000002, 0x00000000, 0x00000000,
0x00000000, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x46454452,
0x00000050, 0x00000000, 0x00000000, 0x00000000, 0x0000001c, 0xfffe0400, 0x00000100, 0x0000001c,
0x7263694d, 0x666f736f, 0x52282074, 0x4c482029, 0x53204c53, 0x65646168, 0x6f432072, 0x6c69706d,
0x39207265, 0x2e39322e, 0x2e323539, 0x31313133, 0xababab00, 0x4e475349, 0x00000050, 0x00000002,
0x00000008, 0x00000038, 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x00000041,
0x00000000, 0x00000000, 0x00000003, 0x00000001, 0x0000000f, 0x49534f50, 0x4e4f4954, 0x5f565300,
0x49534f50, 0x4e4f4954, 0xababab00, 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020,
0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, 0x505f5653, 0x5449534f, 0x004e4f49,
}

Definition at line 93 of file blob.c.

Referenced by test_get_blob_part().

test_blob_part2

DWORD test_blob_part2[]

static

Definition at line 434 of file blob.c.

Referenced by test_get_blob_part2().

test_cso_data

const DWORD test_cso_data[]

static

Initial value:

=
{
 
 
 
 
 
 
 
 
 
 
 
 
 
    0xfffe0200, 0x0014fffe, 0x42415443, 0x0000001c, 0x00000023, 0xfffe0200, 0x00000000, 0x00000000,
    0x00000100, 0x0000001c, 0x325f7376, 0x4d00305f, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820,
    0x6853204c, 0x72656461, 0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, 0x0200001f, 0x80000000,
    0x900f0000, 0x02000001, 0xc00f0000, 0x90e40000, 0x0000ffff
}

Definition at line 795 of file blob.c.

Referenced by test_D3DReadFileToBlob().

UINT

ID3DBlob **static ID3DBlob **static ID3DBlob **static UINT

Definition at line 37 of file blob.c.