asmcache.c File Reference

#include <stdio.h>
#include <windows.h>
#include <mscoree.h>
#include <fusion.h>
#include <corerror.h>
#include "wine/test.h"
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for asmcache.c:

Go to the source code of this file.

Classes
struct	METADATAHDR
struct	METADATASTREAMHDR
struct	METADATATABLESHDR
struct	MODULETABLE
struct	TYPEDEFTABLE
struct	ASSEMBLYTABLE
struct	MANIFESTRESTABLE
struct	IMPORTTABLE
struct	IMPORTLOOKUPTABLE
struct	HINTNAMETABLE
struct	RELOCATION
struct	VS_VERSIONINFO
struct	VARFILEINFO
struct	VAR
struct	STRINGFILEINFO
struct	STRINGTABLE
struct	STRINGHDR
struct	RESOURCE
struct	_tagASSEMBLY

Macros
#define	COBJMACROS
#define	INITGUID
#define	create_file(name, size)   create_file_data(name, name, size)
#define	INIT_ASM_INFO()

Typedefs
typedef struct _tagASSEMBLY	ASSEMBLY

Functions
static	HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache **ppAsmCache
static BOOL	init_functionpointers (void)
static void	create_file_data (LPCSTR name, LPCSTR data, DWORD size)
static void	create_assembly (LPCSTR file)
static BOOL	check_dotnet20 (void)
static void	test_CreateAssemblyCache (void)
static void	test_CreateAssemblyCacheItem (void)
static void	test_InstallAssembly (void)
static void	test_QueryAssemblyInfo (void)
	START_TEST (asmcache)

Variables
static struct _tagASSEMBLY	assembly
static DWORD	dwReserved
static LPWSTR	pwzCachePath
static LPWSTR PDWORD	pcchPath
static LPCWSTR	szVersion
static LPCWSTR LPVOID	pvReserved
static LPCWSTR LPVOID HMODULE *	phModDll

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 19 of file asmcache.c.

create_file

#define create_file	(		name,
			size
	)		create_file_data(name, name, size)

Definition at line 813 of file asmcache.c.

INIT_ASM_INFO

#define INIT_ASM_INFO

(

)

Value:

    ZeroMemory(&info, sizeof(ASSEMBLY_INFO)); \
    info.cbAssemblyInfo = sizeof(ASSEMBLY_INFO); \
    info.pszCurrentAssemblyPathBuf = path; \
    info.cchBuf = MAX_PATH; \
    path[0] = '\0';

Definition at line 1008 of file asmcache.c.

INITGUID

#define INITGUID

Definition at line 20 of file asmcache.c.

Typedef Documentation

ASSEMBLY

typedef struct _tagASSEMBLY ASSEMBLY

Definition at line 31 of file asmcache.c.

Function Documentation

check_dotnet20()

static BOOL check_dotnet20 ( void  )

static

Definition at line 838 of file asmcache.c.

{
    IAssemblyCache *cache;
    HRESULT hr;
    BOOL ret = FALSE;
    ULONG disp;
 
    static const WCHAR winedll[] = {'w','i','n','e','.','d','l','l',0};
 
    create_assembly("wine.dll");
 
    hr = pCreateAssemblyCache(&cache, 0);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    hr = IAssemblyCache_InstallAssembly(cache, 0, winedll, NULL);
    if (hr == S_OK)
        ret = TRUE;
    else if (hr == CLDB_E_FILE_OLDVER)
        win_skip("Tests can't be run on older .NET version (.NET 1.1)\n");
    else if (hr == E_ACCESSDENIED)
        skip("Not enough rights to install an assembly\n");
    else
        ok(0, "Expected S_OK, got %08x\n", hr);
 
    DeleteFileA("wine.dll");
    IAssemblyCache_UninstallAssembly(cache, 0, winedll, NULL, &disp);
    IAssemblyCache_Release(cache);
    return ret;
}

Referenced by START_TEST().

create_assembly()

static void create_assembly ( LPCSTR  file )

static

Definition at line 815 of file asmcache.c.

{
    HANDLE hfile;
    DWORD written;
 
    /* nameless unions initialized here */
    assembly.tableshdr.MaskValid.u.HighPart = 0x101;
    assembly.tableshdr.MaskValid.u.LowPart = 0x00000005;
    assembly.tableshdr.MaskSorted.u.HighPart = 0x1600;
    assembly.tableshdr.MaskSorted.u.LowPart = 0x3301FA00;
    U(assembly.labelres).Name = 0x10;
    U2(assembly.labelres).OffsetToData = 0x80000018;
    U(assembly.label11res).Name = 0x1;
    U2(assembly.label11res).OffsetToData = 0x80000030;
    U(assembly.label10res).Name = 0x0;
    U2(assembly.label10res).OffsetToData = 0x48;
 
    hfile = CreateFileA(file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 
    WriteFile(hfile, &assembly, sizeof(ASSEMBLY), &written, NULL);
    CloseHandle(hfile);
}

Referenced by check_dotnet20(), test_InstallAssembly(), and test_QueryAssemblyInfo().

create_file_data()

static void create_file_data ( LPCSTR  name, LPCSTR  data, DWORD  size  )

static

Definition at line 795 of file asmcache.c.

{
    HANDLE file;
    DWORD written;
 
    file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
    ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
    WriteFile(file, data, strlen(data), &written, NULL);
 
    if (size)
    {
        SetFilePointer(file, size, NULL, FILE_BEGIN);
        SetEndOfFile(file);
    }
 
    CloseHandle(file);
}

Referenced by test_MsiConfigureProductEx(), test_MsiGetFileHash(), test_MsiGetFileSignatureInformation(), test_MsiProvideQualifiedComponentEx(), and test_publish_assemblies().

HRESULT()

static HRESULT ( WINAPI *  pCreateAssemblyCache )

static

init_functionpointers()

static BOOL init_functionpointers ( void  )

static

Definition at line 751 of file asmcache.c.

{
    HRESULT hr;
    HMODULE hfusion;
    HMODULE hmscoree;
 
    static const WCHAR szFusion[] = {'f','u','s','i','o','n','.','d','l','l',0};
 
    hmscoree = LoadLibraryA("mscoree.dll");
    if (!hmscoree)
    {
        win_skip("mscoree.dll not available\n");
        return FALSE;
    }
 
    pLoadLibraryShim = (void *)GetProcAddress(hmscoree, "LoadLibraryShim");
    if (!pLoadLibraryShim)
    {
        win_skip("LoadLibraryShim not available\n");
        FreeLibrary(hmscoree);
        return FALSE;
    }
 
    hr = pLoadLibraryShim(szFusion, NULL, NULL, &hfusion);
    if (FAILED(hr))
    {
        win_skip("fusion.dll not available\n");
        FreeLibrary(hmscoree);
        return FALSE;
    }
 
    pCreateAssemblyCache = (void *)GetProcAddress(hfusion, "CreateAssemblyCache");
    pGetCachePath = (void *)GetProcAddress(hfusion, "GetCachePath");
 
    if (!pCreateAssemblyCache || !pGetCachePath)
    {
        win_skip("fusion.dll not implemented\n");
        return FALSE;
    }
 
    FreeLibrary(hmscoree);
    return TRUE;
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

asmcache

)

Definition at line 1581 of file asmcache.c.

{
    if (!init_functionpointers())
        return;
 
    if (!check_dotnet20())
        return;
 
    test_CreateAssemblyCache();
    test_CreateAssemblyCacheItem();
    test_InstallAssembly();
    test_QueryAssemblyInfo();
}

test_CreateAssemblyCache()

static void test_CreateAssemblyCache ( void  )

static

Definition at line 868 of file asmcache.c.

{
    IAssemblyCache *cache;
    HRESULT hr;
 
    /* NULL ppAsmCache */
    hr = pCreateAssemblyCache(NULL, 0);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    /* dwReserved is non-zero */
    hr = pCreateAssemblyCache(&cache, 42);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    IAssemblyCache_Release(cache);
}

Referenced by START_TEST().

test_CreateAssemblyCacheItem()

static void test_CreateAssemblyCacheItem ( void  )

static

Definition at line 884 of file asmcache.c.

{
    IAssemblyCache *cache;
    IAssemblyCacheItem *item;
    HRESULT hr;
 
    static const WCHAR wine[] = {'w','i','n','e',0};
 
    hr = pCreateAssemblyCache(&cache, 0);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    hr = IAssemblyCache_CreateAssemblyCacheItem(cache, 0, NULL, NULL, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    hr = IAssemblyCache_CreateAssemblyCacheItem(cache, 0, NULL, &item, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    IAssemblyCacheItem_Release(item);
 
    hr = IAssemblyCache_CreateAssemblyCacheItem(cache, 0, NULL, &item, wine);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    IAssemblyCacheItem_Release(item);
 
    hr = IAssemblyCache_CreateAssemblyCacheItem(cache, 1, (void *)0xdeadbeef, &item, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    IAssemblyCacheItem_Release(item);
 
    hr = IAssemblyCache_CreateAssemblyCacheItem(cache, 1, NULL, &item, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    IAssemblyCacheItem_Release(item);
 
    hr = IAssemblyCache_CreateAssemblyCacheItem(cache, 0, (void *)0xdeadbeef, &item, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    IAssemblyCacheItem_Release(item);
 
    IAssemblyCache_Release(cache);
}

Referenced by START_TEST().

test_InstallAssembly()

static void test_InstallAssembly ( void  )

static

Definition at line 921 of file asmcache.c.

{
    IAssemblyCache *cache;
    HRESULT hr;
    ULONG disp;
    DWORD attr;
    char dllpath[MAX_PATH];
 
    static const WCHAR empty[] = {0};
    static const WCHAR noext[] = {'f','i','l','e',0};
    static const WCHAR badext[] = {'f','i','l','e','.','b','a','d',0};
    static const WCHAR dllext[] = {'f','i','l','e','.','d','l','l',0};
    static const WCHAR exeext[] = {'f','i','l','e','.','e','x','e',0};
    static const WCHAR testdll[] = {'t','e','s','t','.','d','l','l',0};
    static const WCHAR winedll[] = {'w','i','n','e','.','d','l','l',0};
    static const WCHAR wine[] = {'w','i','n','e',0};
 
    create_file("test.dll", 100);
    create_assembly("wine.dll");
 
    hr = pCreateAssemblyCache(&cache, 0);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    /* NULL pszManifestFilePath */
    hr = IAssemblyCache_InstallAssembly(cache, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    /* empty pszManifestFilePath */
    hr = IAssemblyCache_InstallAssembly(cache, 0, empty, NULL);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 
    /* pszManifestFilePath has no extension */
    hr = IAssemblyCache_InstallAssembly(cache, 0, noext, NULL);
    ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME),
       "Expected HRESULT_FROM_WIN32(ERROR_INVALID_NAME), got %08x\n", hr);
 
    /* pszManifestFilePath has bad extension */
    hr = IAssemblyCache_InstallAssembly(cache, 0, badext, NULL);
    ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME),
       "Expected HRESULT_FROM_WIN32(ERROR_INVALID_NAME), got %08x\n", hr);
 
    /* pszManifestFilePath has dll extension */
    hr = IAssemblyCache_InstallAssembly(cache, 0, dllext, NULL);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
 
    /* pszManifestFilePath has exe extension */
    hr = IAssemblyCache_InstallAssembly(cache, 0, exeext, NULL);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
 
    /* empty file */
    hr = IAssemblyCache_InstallAssembly(cache, 0, testdll, NULL);
    ok(hr == COR_E_ASSEMBLYEXPECTED,
       "Expected COR_E_ASSEMBLYEXPECTED, got %08x\n", hr);
 
    /* wine assembly */
    hr = IAssemblyCache_InstallAssembly(cache, 0, winedll, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    GetWindowsDirectoryA(dllpath, MAX_PATH);
    strcat(dllpath, "\\assembly\\GAC_MSIL\\wine\\\\1.0.0.0__2d03617b1c31e2f5\\wine.dll");
 
    attr = GetFileAttributesA(dllpath);
    ok(attr != INVALID_FILE_ATTRIBUTES, "Expected assembly to exist\n");
 
    /* uninstall the assembly from the GAC */
    disp = 0xf00dbad;
    hr = IAssemblyCache_UninstallAssembly(cache, 0, wine, NULL, &disp);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(disp == IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED,
       "Expected IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED, got %d\n", disp);
 
    attr = GetFileAttributesA(dllpath);
    ok(attr == INVALID_FILE_ATTRIBUTES, "Expected assembly not to exist\n");
 
    disp = 0xf00dbad;
    hr = IAssemblyCache_UninstallAssembly(cache, 0, wine, NULL, &disp);
    ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr);
    ok(disp == IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED,
       "Expected IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED, got %d\n", disp);
 
    DeleteFileA("test.dll");
    DeleteFileA("wine.dll");
    IAssemblyCache_Release(cache);
}

Referenced by START_TEST().

test_QueryAssemblyInfo()

static void test_QueryAssemblyInfo ( void  )

static

Definition at line 1015 of file asmcache.c.

{
    IAssemblyCache *cache;
    ASSEMBLY_INFO info;
    WCHAR path[MAX_PATH];
    WCHAR asmpath[MAX_PATH];
    WCHAR name[MAX_PATH];
    HRESULT hr;
    DWORD size;
    ULONG disp;
 
    static const WCHAR empty[] = {0};
    static const WCHAR commasep[] = {',',' ',0};
    static const WCHAR winedll[] = {'w','i','n','e','.','d','l','l',0};
    static const WCHAR wine[] = {'w','i','n','e',0};
    static const WCHAR ver[] = {
        'V','e','r','s','i','o','n','=','1','.','0','.','0','.','0',0};
    static const WCHAR otherver[] = {
        'V','e','r','s','i','o','n','=','1','.','0','.','0','.','0','0','0','0','0',0};
    static const WCHAR badver[] = {
        'V','e','r','s','i','o','n','=','1','.','0','.','0','.','1',0};
    static const WCHAR culture[] = {
        'C','u','l','t','u','r','e','=','n','e','u','t','r','a','l',0};
    static const WCHAR badculture[] = {
        'C','u','l','t','u','r','e','=','e','n',0};
    static const WCHAR pubkey[] = {
        'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=',
        '2','d','0','3','6','1','7','b','1','c','3','1','e','2','f','5',0};
    static const WCHAR badpubkey[] = {
        'P','u','b','l','i','c','K','e','y','T','o','k','e','n','=',
        'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0};
    static const WCHAR badprop[] = {'B','a','d','P','r','o','p','=','b','u','h',0};
    static const WCHAR msil[] = {
        '_','M','S','I','L','\\','w','i','n','e','\\',
        '1','.','0','.','0','.','0','_','_','2','d','0','3','6','1','7','b',
        '1','c','3','1','e','2','f','5','\\',0};
    static const WCHAR wine2[] = {
        'w','i','n','e',',','v','e','r','s','i','o','n','=','1','.','0','.','0','.','1',',',
        'p','u','b','l','i','c','K','e','y','T','o','k','e','n','=',
        '2','d','0','3','6','1','7','b','1','c','3','1','e','2','f','5',',',
        'c','u','l','t','u','r','e','=','n','e','u','t','r','a','l',0};
    static const WCHAR nullpublickey[] = {
        'm','s','c','o','r','l','i','b','.','d','l','l',',','v','e','r','s','i','o','n','=','0','.','0','.',
        '0','.','0',',','c','u','l','t','u','r','e','=','n','e','u','t','r','a','l',',',
        'p','u','b','l','i','c','K','e','y','T','o','k','e','n','=','n','u','l','l',0};
    static const WCHAR nullpublickey1[] = {
        'm','s','c','o','r','l','i','b','.','d','l','l',',',
        'p','u','b','l','i','c','K','e','y','T','o','k','e','n','=','n','u','L','l',0};
 
    size = MAX_PATH;
    hr = pGetCachePath(ASM_CACHE_GAC, asmpath, &size);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    lstrcatW(asmpath, msil);
    lstrcatW(asmpath, winedll);
 
    create_assembly("wine.dll");
 
    hr = pCreateAssemblyCache(&cache, 0);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    /* assembly not installed yet */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, 0, wine, &info);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    hr = IAssemblyCache_InstallAssembly(cache, 0, winedll, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    /* NULL pszAssemblyName */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_VALIDATE,
                                          NULL, &info);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* empty pszAssemblyName */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_VALIDATE,
                                          empty, &info);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* no dwFlags */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, 0, wine, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* pwzCachePath is full filename */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, 0, winedll, &info);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* NULL pAsmInfo, QUERYASMINFO_FLAG_VALIDATE */
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_VALIDATE,
                                          wine, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    /* NULL pAsmInfo, QUERYASMINFO_FLAG_GETSIZE */
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          wine, NULL);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 
    /* info.cbAssemblyInfo is 0 */
    INIT_ASM_INFO();
    info.cbAssemblyInfo = 0;
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_VALIDATE,
                                          wine, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* info.cbAssemblyInfo is 1 */
    INIT_ASM_INFO();
    info.cbAssemblyInfo = 1;
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_VALIDATE,
                                          wine, &info);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
    ok(info.cbAssemblyInfo == 1, "Expected 1, got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* info.cbAssemblyInfo is > sizeof(ASSEMBLY_INFO) */
    INIT_ASM_INFO();
    info.cbAssemblyInfo = sizeof(ASSEMBLY_INFO) * 2;
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          wine, &info);
    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO) * 2,
       "Expected sizeof(ASSEMBLY_INFO) * 2, got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* QUERYASMINFO_FLAG_GETSIZE */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          wine, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* QUERYASMINFO_FLAG_GETSIZE and QUERYASMINFO_FLAG_VALIDATE */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE |
                                          QUERYASMINFO_FLAG_VALIDATE,wine, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* info.pszCurrentAssemblyPathBuf is NULL */
    INIT_ASM_INFO();
    info.pszCurrentAssemblyPathBuf = NULL;
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          wine, &info);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Expected E_NOT_SUFFICIENT_BUFFER, got %08x\n", hr);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* info.cchBuf is exactly size of asmpath */
    INIT_ASM_INFO();
    info.cchBuf = lstrlenW(asmpath);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          wine, &info);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Expected E_NOT_SUFFICIENT_BUFFER, got %08x\n", hr);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* info.cchBuf has room for NULL-terminator */
    INIT_ASM_INFO();
    info.cchBuf = lstrlenW(asmpath) + 1;
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          wine, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
 
    /* display name is "wine, Version=1.0.0.0" */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, ver);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* short buffer, QUERYASMINFO_FLAG_VALIDATE */
    memset(&info, 0, sizeof(info));
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, otherver);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_VALIDATE,
                                          name, &info);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "got %08x\n", hr);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED, "got %08x\n", info.dwAssemblyFlags);
 
    /* short buffer, QUERYASMINFO_FLAG_GETSIZE */
    memset(&info, 0, sizeof(info));
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, otherver);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "got %08x\n", hr);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED, "got %08x\n", info.dwAssemblyFlags);
 
    /* display name is "wine, Version=1.0.0.00000" */
    INIT_ASM_INFO();
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* display name is "wine, Version=1.0.0.1", versions don't match */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, badver);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* display name is "wine,version=1.0.0.1,publicKeyToken=2d03617b1c31e2f5,culture=neutral" */
    INIT_ASM_INFO();
    lstrcpyW(name, wine2);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* display name is "mscorlib.dll,version=0.0.0.0,culture=neutral,publicKeyToken=null" */
    INIT_ASM_INFO();
    lstrcpyW(name, nullpublickey);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, 0, name, &info);
    ok(hr == FUSION_E_PRIVATE_ASM_DISALLOWED, "got %08x\n", hr);
 
    /* display name is "mscorlib.dll,publicKeyToken=nuLl" */
    INIT_ASM_INFO();
    lstrcpyW(name, nullpublickey1);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, 0, name, &info);
    ok(hr == FUSION_E_PRIVATE_ASM_DISALLOWED, "got %08x\n", hr);
 
    /* display name is "wine, Culture=neutral" */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, culture);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* display name is "wine, Culture=en", cultures don't match */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, badculture);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* display name is "wine, PublicKeyTokens=2d03617b1c31e2f5" */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, pubkey);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* display name is "wine, PublicKeyToken=aaaaaaaaaaaaaaaa", pubkeys don't match */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, badpubkey);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
       "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == 0, "Expected 0, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    ok(info.uliAssemblySizeInKB.u.LowPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, empty),
       "Assembly path was changed\n");
    ok(info.cchBuf == MAX_PATH, "Expected MAX_PATH, got %d\n", info.cchBuf);
 
    /* display name is "wine, BadProp=buh", bad property */
    INIT_ASM_INFO();
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, badprop);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, QUERYASMINFO_FLAG_GETSIZE,
                                          name, &info);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
    ok(info.uliAssemblySizeInKB.u.HighPart == 0,
       "Expected 0, got %d\n", info.uliAssemblySizeInKB.u.HighPart);
    todo_wine
    {
        ok((info.uliAssemblySizeInKB.u.LowPart == 4),
           "Expected 4, got %d\n", info.uliAssemblySizeInKB.u.LowPart);
    }
    ok(!lstrcmpW(info.pszCurrentAssemblyPathBuf, asmpath),
       "Wrong assembly path returned\n");
    ok(info.cchBuf == lstrlenW(asmpath) + 1,
       "Expected %d, got %d\n", lstrlenW(asmpath) + 1, info.cchBuf);
 
    /* no flags, display name is "wine, Version=1.0.0.0" */
    INIT_ASM_INFO();
    info.pszCurrentAssemblyPathBuf = NULL;
    info.cchBuf = 0;
    lstrcpyW(name, wine);
    lstrcatW(name, commasep);
    lstrcatW(name, ver);
    hr = IAssemblyCache_QueryAssemblyInfo(cache, 0, name, &info);
    ok(hr == E_NOT_SUFFICIENT_BUFFER, "Expected E_NOT_SUFFICIENT_BUFFER, got %08x\n", hr);
    ok(info.cbAssemblyInfo == sizeof(ASSEMBLY_INFO),
       "Expected sizeof(ASSEMBLY_INFO), got %d\n", info.cbAssemblyInfo);
    ok(info.dwAssemblyFlags == ASSEMBLYINFO_FLAG_INSTALLED,
       "Expected ASSEMBLYINFO_FLAG_INSTALLED, got %08x\n", info.dwAssemblyFlags);
 
    /* uninstall the assembly from the GAC */
    disp = 0xf00dbad;
    hr = IAssemblyCache_UninstallAssembly(cache, 0, wine, NULL, &disp);
    ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
    ok(disp == IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED,
       "Expected IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED, got %d\n", disp);
 
    DeleteFileA("test.dll");
    DeleteFileA("wine.dll");
    IAssemblyCache_Release(cache);
}

Referenced by START_TEST().

Variable Documentation

assembly

struct _tagASSEMBLY assembly

static

dwReserved

DWORD dwReserved

Definition at line 745 of file asmcache.c.

pcchPath

LPWSTR PDWORD pcchPath

Definition at line 747 of file asmcache.c.

Referenced by GetCachePath(), MsiProvideComponentFromDescriptorA(), MsiProvideComponentFromDescriptorW(), PathCreateFromUrlA(), PathCreateFromUrlW(), and UriBuilder_GetPath().

phModDll

LPCWSTR LPVOID HMODULE* phModDll

Definition at line 749 of file asmcache.c.

Referenced by LoadLibraryShim().

pvReserved

LPCWSTR LPVOID pvReserved

Definition at line 749 of file asmcache.c.

pwzCachePath

LPWSTR pwzCachePath

Definition at line 747 of file asmcache.c.

Referenced by GetCachePath().

szVersion

LPCWSTR szVersion

Definition at line 748 of file asmcache.c.

Referenced by capGetDriverDescriptionW(), CorBindToRuntimeEx(), fill_file_description(), GetInstalledVersion_WowUser(), HTTP_KeepAlive(), HttpOpenRequestA(), Installer_VersionGet(), LoadLibraryShim(), OnPaint(), set_cookie(), SHAboutInfoW(), and test_xmldoc().