actctx.c File Reference

#include "ntstatus.h"
#include "wine/test.h"
#include <winbase.h>
#include <windef.h>
#include <winnt.h>
#include <winternl.h>
#include <winnls.h>
#include <stdio.h>
#include "oaidl.h"
#include "initguid.h"

Include dependency graph for actctx.c:

Go to the source code of this file.

Classes
struct	detailed_info_t
struct	info_in_assembly
struct	runlevel_info_t
struct	strsection_header
struct	string_index
struct	guidsection_header
struct	guid_index
struct	wndclass_redirect_data
struct	dllredirect_data
struct	tlibredirect_data
struct	progidredirect_data
struct	comclassredirect_data
struct	clrclass_data
struct	ifacepsredirect_data
struct	clrsurrogate_data
struct	_test_act_ctx_compat_info

Macros
#define	WIN32_NO_STATUS
#define	ARCH   "none"
#define	X(f)   if (!(p##f = (void*)GetProcAddress(hLibrary, #f))) return FALSE;

Typedefs
typedef struct _test_act_ctx_compat_info	test_act_ctx_compat_info

Enumerations
enum	comclass_threadingmodel {   ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 , ThreadingModel_No = 3 , ThreadingModel_Both = 4 ,   ThreadingModel_Neutral = 5 , ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 , ThreadingModel_No = 3 ,   ThreadingModel_Both = 4 , ThreadingModel_Neutral = 5 , ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 ,   ThreadingModel_No = 3 , ThreadingModel_Both = 4 , ThreadingModel_Neutral = 5 }
enum	comclass_miscfields {   MiscStatus = 1 , MiscStatusIcon = 2 , MiscStatusContent = 4 , MiscStatusThumbnail = 8 ,   MiscStatusDocPrint = 16 , MiscStatus = 1 , MiscStatusIcon = 2 , MiscStatusContent = 4 ,   MiscStatusThumbnail = 8 , MiscStatusDocPrint = 16 , MiscStatus = 1 , MiscStatusIcon = 2 ,   MiscStatusContent = 4 , MiscStatusThumbnail = 8 , MiscStatusDocPrint = 16 }
enum	ifaceps_mask { NumMethods = 1 , BaseIface = 2 , NumMethods = 1 , BaseIface = 2 }

Functions
static	BOOL (WINAPI *pActivateActCtx)(HANDLE
static ULONG_PTR *static	HANDLE (WINAPI *pCreateActCtxA)(PCACTCTXA)
static SIZE_T *static	VOID (WINAPI *pReleaseActCtx)(HANDLE)
static	NTSTATUS (NTAPI *pRtlFindActivationContextSectionString)(DWORD
static	BOOLEAN (NTAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING
static	VOID (NTAPI *pRtlFreeUnicodeString)(PUNICODE_STRING)
static const char *	strw (LPCWSTR x)
	DEFINE_GUID (IID_CoTest, 0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33)
	DEFINE_GUID (IID_CoTest2, 0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x11, 0x11, 0x22, 0x22, 0x33, 0x34)
	DEFINE_GUID (CLSID_clrclass, 0x22345678, 0x1234, 0x5678, 0x12, 0x34, 0x11, 0x11, 0x22, 0x22, 0x33, 0x33)
	DEFINE_GUID (IID_TlibTest, 0x99999999, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55)
	DEFINE_GUID (IID_TlibTest2, 0x99999999, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x56)
	DEFINE_GUID (IID_TlibTest3, 0x99999999, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x57)
	DEFINE_GUID (IID_TlibTest4, 0x99999999, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x58)
	DEFINE_GUID (IID_Iifaceps, 0x66666666, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55)
	DEFINE_GUID (IID_Ibifaceps, 0x66666666, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x57)
	DEFINE_GUID (IID_Iifaceps2, 0x76666666, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55)
	DEFINE_GUID (IID_Iifaceps3, 0x86666666, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55)
	DEFINE_GUID (IID_Iiface, 0x96666666, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55)
	DEFINE_GUID (IID_PS32, 0x66666666, 0x8888, 0x7777, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x55, 0x56)
	DEFINE_GUID (VISTA_COMPAT_GUID, 0xe2011457, 0x1546, 0x43c5, 0xa5, 0xfe, 0x00, 0x8d, 0xee, 0xe3, 0xd3, 0xf0)
	DEFINE_GUID (WIN7_COMPAT_GUID, 0x35138b9a, 0x5d96, 0x4fbd, 0x8e, 0x2d, 0xa2, 0x44, 0x02, 0x25, 0xf9, 0x3a)
	DEFINE_GUID (WIN8_COMPAT_GUID, 0x4a2f28e3, 0x53b9, 0x4441, 0xba, 0x9c, 0xd6, 0x9d, 0x4a, 0x4a, 0x6e, 0x38)
	DEFINE_GUID (WIN81_COMPAT_GUID, 0x1f676c76, 0x80e1, 0x4239, 0x95, 0xbb, 0x83, 0xd0, 0xf6, 0xd0, 0xda, 0x78)
	DEFINE_GUID (WIN10_COMPAT_GUID, 0x8e0f7a12, 0xbfb3, 0x4fe8, 0xb9, 0xa5, 0x48, 0xfd, 0x50, 0xa1, 0x5a, 0x9a)
	DEFINE_GUID (OTHER_COMPAT_GUID, 0x12345566, 0x1111, 0x2222, 0x33, 0x33, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44)
static int	strcmp_aw (LPCWSTR strw, const char *stra)
static DWORD	strlen_aw (const char *str)
static BOOL	create_manifest_file (const char *filename, const char *manifest, int manifest_len, const char *depfile, const char *depmanifest)
static BOOL	create_wide_manifest (const char *filename, const char *manifest, BOOL fBOM, BOOL fReverse)
static void	test_detailed_info (HANDLE handle, const detailed_info_t *exinfo, int line)
static void	test_info_in_assembly (HANDLE handle, DWORD id, const info_in_assembly *exinfo, int line)
static void	test_file_info (HANDLE handle, ULONG assid, ULONG fileid, LPCWSTR filename, int line)
static void	test_runlevel_info (HANDLE handle, const runlevel_info_t *exinfo, int line)
static HANDLE	test_create (const char *file)
static void	test_create_and_fail (const char *manifest, const char *depmanifest, int todo, BOOL is_broken)
static void	test_create_wide_and_fail (const char *manifest, BOOL fBOM)
static void	test_create_fail (void)
static void	test_find_dll_redirection (HANDLE handle, LPCWSTR libname, ULONG exid, int line)
static void	test_find_window_class (HANDLE handle, LPCWSTR clsname, ULONG exid, int line)
static void	test_find_string_fail (void)
static void	test_basic_info (HANDLE handle, int line)
static void	test_find_com_redirection (HANDLE handle, const GUID *clsid, const GUID *tlid, const WCHAR *progid, ULONG exid, int line)
static void	test_find_ifaceps_redirection (HANDLE handle, const GUID *iid, const GUID *tlbid, const GUID *base, const GUID *ps32, ULONG exid, int line)
static void	test_find_surrogate (HANDLE handle, const GUID *clsid, const WCHAR *name, const WCHAR *version, ULONG exid, int line)
static void	test_find_progid_redirection (HANDLE handle, const GUID *clsid, const char *progid, ULONG exid, int line)
static void	test_wndclass_section (void)
static void	test_dllredirect_section (void)
static void	test_typelib_section (void)
static void	test_allowDelayedBinding (void)
static void	test_actctx (void)
static void	test_app_manifest (void)
static HANDLE	create_manifest (const char *filename, const char *data, int line)
static void	kernel32_find (ULONG section, const char *string_to_find, BOOL should_find, int line)
static void	ntdll_find (ULONG section, const char *string_to_find, BOOL should_find, int line)
static void	test_findsectionstring (void)
static void	run_child_process (void)
static void	init_paths (void)
static void	write_manifest (const char *filename, const char *manifest)
static void	delete_manifest_file (const char *filename)
static void	test_CreateActCtx (void)
static BOOL	init_funcs (void)
static void	test_ZombifyActCtx (void)
static void	test_no_compat (HANDLE handle, int line)
static void	test_with_compat (HANDLE handle, DWORD num_compat, const GUID *expected_compat[], int line)
static void	test_compatibility (void)
	START_TEST (actctx)

Variables
static	ULONG_PTR
static const GUID	ULONG
static const GUID	LPCSTR
static const GUID	PACTCTX_SECTION_KEYED_DATA
static const GUID	LPCWSTR
static	HANDLE
static	PVOID
static	SIZE_T
static const GUID	PUNICODE_STRING
static	PCSZ
static const char	manifest1 []
static const char	manifest1_1 []
static const char	manifest2 []
static const char	manifest3 []
static const char	manifest_wndcls1 []
static const char	manifest_wndcls2 []
static const char	manifest_wndcls_main []
static const char	manifest4 []
static const char	manifest5 []
static const char	manifest6 []
static const char	manifest7 []
static const char	manifest8 []
static const char	manifest9 []
static const char	testdep_manifest1 []
static const char	testdep_manifest2 []
static const char	testdep_manifest3 []
static const char	wrong_manifest1 []
static const char	wrong_manifest2 []
static const char	wrong_manifest3 []
static const char	wrong_manifest4 []
static const char	wrong_manifest5 []
static const char	wrong_manifest6 []
static const char	wrong_manifest7 []
static const char	wrong_manifest8 []
static const char	wrong_manifest9 []
static const char	wrong_manifest10 []
static const char	wrong_depmanifest1 []
static const char	compat_manifest_no_supportedOs []
static const char	compat_manifest_vista []
static const char	compat_manifest_vista_7_8_10_81 []
static const char	compat_manifest_other_guid []
static const WCHAR	testlib_dll []
static const WCHAR	testlib2_dll []
static const WCHAR	wndClassW []
static const WCHAR	wndClass1W []
static const WCHAR	wndClass2W []
static const WCHAR	wndClass3W []
static WCHAR	app_dir [MAX_PATH]
static WCHAR	exe_path [MAX_PATH]
static WCHAR	work_dir [MAX_PATH]
static WCHAR	work_dir_subdir [MAX_PATH]
static WCHAR	app_manifest_path [MAX_PATH]
static WCHAR	manifest_path [MAX_PATH]
static WCHAR	depmanifest_path [MAX_PATH]
static const detailed_info_t	detailed_info0
static const detailed_info_t	detailed_info1
static const detailed_info_t	detailed_info1_child
static const detailed_info_t	detailed_info2
static const info_in_assembly	manifest1_info
static const info_in_assembly	manifest1_child_info
static const info_in_assembly	manifest2_info
static const info_in_assembly	manifest3_info
static const info_in_assembly	manifest4_info
static const info_in_assembly	depmanifest1_info
static const info_in_assembly	depmanifest2_info
static const info_in_assembly	depmanifest3_info
static const info_in_assembly	manifest_comctrl_info
static const runlevel_info_t	runlevel_info0
static const runlevel_info_t	runlevel_info6
static const runlevel_info_t	runlevel_info7
static const runlevel_info_t	runlevel_info8
static const runlevel_info_t	runlevel_info9

Macro Definition Documentation

ARCH

#define ARCH   "none"

Definition at line 68 of file actctx.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 20 of file actctx.c.

X

#define X

(

f

)

if (!(p##f = (void*)GetProcAddress(hLibrary, #f))) return FALSE;

Typedef Documentation

test_act_ctx_compat_info

typedef struct _test_act_ctx_compat_info test_act_ctx_compat_info

Enumeration Type Documentation

comclass_miscfields

enum comclass_miscfields

Enumerator
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint

Definition at line 1371 of file actctx.c.

                         {
    MiscStatus          = 1,
    MiscStatusIcon      = 2,
    MiscStatusContent   = 4,
    MiscStatusThumbnail = 8,
    MiscStatusDocPrint  = 16
};

comclass_threadingmodel

enum comclass_threadingmodel

Enumerator
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral

Definition at line 1363 of file actctx.c.

                             {
    ThreadingModel_Apartment = 1,
    ThreadingModel_Free      = 2,
    ThreadingModel_No        = 3,
    ThreadingModel_Both      = 4,
    ThreadingModel_Neutral   = 5
};

ifaceps_mask

enum ifaceps_mask

Enumerator
NumMethods
BaseIface
NumMethods
BaseIface

Definition at line 1554 of file actctx.c.

{
    NumMethods = 1,
    BaseIface  = 2
};

Function Documentation

BOOL()

static BOOL ( WINAPI *  pActivateActCtx )

static

BOOLEAN()

static BOOLEAN ( NTAPI *  pRtlCreateUnicodeStringFromAsciiz )

static

create_manifest()

static HANDLE create_manifest ( const char *  filename, const char *  data, int  line  )

static

Definition at line 2320 of file actctx.c.

{
    HANDLE handle;
    create_manifest_file(filename, data, -1, NULL, NULL);
 
    handle = test_create(filename);
    ok_(__FILE__, line)(handle != INVALID_HANDLE_VALUE,
        "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
 
    DeleteFileA(filename);
    return handle;
}

Referenced by test_findsectionstring(), and test_ZombifyActCtx().

create_manifest_file()

static BOOL create_manifest_file ( const char *  filename, const char *  manifest, int  manifest_len, const char *  depfile, const char *  depmanifest  )

static

Definition at line 486 of file actctx.c.

{
    DWORD size;
    HANDLE file;
    WCHAR path[MAX_PATH];
 
    MultiByteToWideChar( CP_ACP, 0, filename, -1, path, MAX_PATH );
    GetFullPathNameW(path, sizeof(manifest_path)/sizeof(WCHAR), manifest_path, NULL);
 
    if (manifest_len == -1)
        manifest_len = strlen(manifest);
 
    file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                       FILE_ATTRIBUTE_NORMAL, NULL);
    ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
    if(file == INVALID_HANDLE_VALUE)
        return FALSE;
    WriteFile(file, manifest, manifest_len, &size, NULL);
    CloseHandle(file);
 
    if (depmanifest)
    {
        MultiByteToWideChar( CP_ACP, 0, depfile, -1, path, MAX_PATH );
        GetFullPathNameW(path, sizeof(depmanifest_path)/sizeof(WCHAR), depmanifest_path, NULL);
        file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                           FILE_ATTRIBUTE_NORMAL, NULL);
        ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
        if(file == INVALID_HANDLE_VALUE)
            return FALSE;
        WriteFile(file, depmanifest, strlen(depmanifest), &size, NULL);
        CloseHandle(file);
    }
    return TRUE;
}

Referenced by create_manifest(), create_wide_manifest(), run_child_process(), test_actctx(), test_allowDelayedBinding(), test_compatibility(), test_create_and_fail(), test_dllredirect_section(), test_LoadRegTypeLib(), test_typelib_section(), and test_wndclass_section().

create_wide_manifest()

static BOOL create_wide_manifest ( const char *  filename, const char *  manifest, BOOL  fBOM, BOOL  fReverse  )

static

Definition at line 522 of file actctx.c.

{
    WCHAR *wmanifest = HeapAlloc(GetProcessHeap(), 0, (strlen(manifest)+2) * sizeof(WCHAR));
    BOOL ret;
    int offset = (fBOM ? 0 : 1);
 
    MultiByteToWideChar(CP_ACP, 0, manifest, -1, &wmanifest[1], (strlen(manifest)+1));
    wmanifest[0] = 0xfeff;
    if (fReverse)
    {
        size_t i;
        for (i = 0; i < strlen(manifest)+1; i++)
            wmanifest[i] = (wmanifest[i] << 8) | ((wmanifest[i] >> 8) & 0xff);
    }
    ret = create_manifest_file(filename, (char *)&wmanifest[offset], (strlen(manifest)+1-offset) * sizeof(WCHAR), NULL, NULL);
    HeapFree(GetProcessHeap(), 0, wmanifest);
    return ret;
}

Referenced by test_actctx(), and test_create_wide_and_fail().

DEFINE_GUID() [1/19]

DEFINE_GUID	(	CLSID_clrclass	,
		0x22345678	,
		0x1234	,
		0x5678	,
		0x12	,
		0x34	,
		0x11	,
		0x11	,
		0x22	,
		0x22	,
		0x33	,
		0x33
	)

DEFINE_GUID() [2/19]

DEFINE_GUID	(	IID_CoTest	,
		0x12345678	,
		0x1234	,
		0x5678	,
		0x12	,
		0x34	,
		0x11	,
		0x11	,
		0x22	,
		0x22	,
		0x33	,
		0x33
	)

DEFINE_GUID() [3/19]

DEFINE_GUID	(	IID_CoTest2	,
		0x12345678	,
		0x1234	,
		0x5678	,
		0x12	,
		0x34	,
		0x11	,
		0x11	,
		0x22	,
		0x22	,
		0x33	,
		0x34
	)

DEFINE_GUID() [4/19]

DEFINE_GUID	(	IID_Ibifaceps	,
		0x66666666	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x57
	)

DEFINE_GUID() [5/19]

DEFINE_GUID	(	IID_Iiface	,
		0x96666666	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55
	)

DEFINE_GUID() [6/19]

DEFINE_GUID	(	IID_Iifaceps	,
		0x66666666	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55
	)

DEFINE_GUID() [7/19]

DEFINE_GUID	(	IID_Iifaceps2	,
		0x76666666	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55
	)

DEFINE_GUID() [8/19]

DEFINE_GUID	(	IID_Iifaceps3	,
		0x86666666	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55
	)

DEFINE_GUID() [9/19]

DEFINE_GUID	(	IID_PS32	,
		0x66666666	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x56
	)

DEFINE_GUID() [10/19]

DEFINE_GUID	(	IID_TlibTest	,
		0x99999999	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55
	)

DEFINE_GUID() [11/19]

DEFINE_GUID	(	IID_TlibTest2	,
		0x99999999	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x56
	)

DEFINE_GUID() [12/19]

DEFINE_GUID	(	IID_TlibTest3	,
		0x99999999	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x57
	)

DEFINE_GUID() [13/19]

DEFINE_GUID	(	IID_TlibTest4	,
		0x99999999	,
		0x8888	,
		0x7777	,
		0x66	,
		0x66	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x55	,
		0x58
	)

DEFINE_GUID() [14/19]

DEFINE_GUID	(	OTHER_COMPAT_GUID	,
		0x12345566	,
		0x1111	,
		0x2222	,
		0x33	,
		0x33	,
		0x44	,
		0x44	,
		0x44	,
		0x44	,
		0x44	,
		0x44
	)

DEFINE_GUID() [15/19]

DEFINE_GUID	(	VISTA_COMPAT_GUID	,
		0xe2011457	,
		0x1546	,
		0x43c5	,
		0xa5	,
		0xfe	,
		0x00	,
		0x8d	,
		0xee	,
		0xe3	,
		0xd3	,
		0xf0
	)

DEFINE_GUID() [16/19]

DEFINE_GUID	(	WIN10_COMPAT_GUID	,
		0x8e0f7a12	,
		0xbfb3	,
		0x4fe8	,
		0xb9	,
		0xa5	,
		0x48	,
		0xfd	,
		0x50	,
		0xa1	,
		0x5a	,
		0x9a
	)

DEFINE_GUID() [17/19]

DEFINE_GUID	(	WIN7_COMPAT_GUID	,
		0x35138b9a	,
		0x5d96	,
		0x4fbd	,
		0x8e	,
		0x2d	,
		0xa2	,
		0x44	,
		0x02	,
		0x25	,
		0xf9	,
		0x3a
	)

DEFINE_GUID() [18/19]

DEFINE_GUID	(	WIN81_COMPAT_GUID	,
		0x1f676c76	,
		0x80e1	,
		0x4239	,
		0x95	,
		0xbb	,
		0x83	,
		0xd0	,
		0xf6	,
		0xd0	,
		0xda	,
		0x78
	)

DEFINE_GUID() [19/19]

DEFINE_GUID	(	WIN8_COMPAT_GUID	,
		0x4a2f28e3	,
		0x53b9	,
		0x4441	,
		0xba	,
		0x9c	,
		0xd6	,
		0x9d	,
		0x4a	,
		0x4a	,
		0x6e	,
		0x38
	)

delete_manifest_file()

static void delete_manifest_file ( const char *  filename )

static

Definition at line 2515 of file actctx.c.

{
    CHAR path[MAX_PATH];
 
    GetTempPathA(sizeof(path)/sizeof(CHAR), path);
    strcat(path, filename);
    DeleteFileA(path);
}

Referenced by test_CreateActCtx().

HANDLE()

static ULONG_PTR *static HANDLE ( WINAPI *  pCreateActCtxA )

static

init_funcs()

static BOOL init_funcs ( void  )

static

Definition at line 2651 of file actctx.c.

{
    HMODULE hLibrary = GetModuleHandleA("kernel32.dll");
 
#define X(f) if (!(p##f = (void*)GetProcAddress(hLibrary, #f))) return FALSE;
    X(ActivateActCtx);
    X(CreateActCtxA);
    X(CreateActCtxW);
    X(DeactivateActCtx);
    X(FindActCtxSectionStringA);
    X(FindActCtxSectionStringW);
    X(GetCurrentActCtx);
    X(IsDebuggerPresent);
    X(QueryActCtxW);
    X(ReleaseActCtx);
    X(FindActCtxSectionGuid);
    X(ZombifyActCtx);
 
    hLibrary = GetModuleHandleA("ntdll.dll");
    X(RtlFindActivationContextSectionString);
    X(RtlCreateUnicodeStringFromAsciiz);
    X(RtlFreeUnicodeString);
#undef X
 
    return TRUE;
}

Referenced by START_TEST().

init_paths()

static void init_paths ( void  )

static

Definition at line 2476 of file actctx.c.

{
    LPWSTR ptr;
 
    static const WCHAR dot_manifest[] = {'.','M','a','n','i','f','e','s','t',0};
    static const WCHAR backslash[] = {'\\',0};
    static const WCHAR subdir[] = {'T','e','s','t','S','u','b','d','i','r','\\',0};
 
    GetModuleFileNameW(NULL, exe_path, sizeof(exe_path)/sizeof(WCHAR));
    lstrcpyW(app_dir, exe_path);
    for(ptr=app_dir+lstrlenW(app_dir); *ptr != '\\' && *ptr != '/'; ptr--);
    ptr[1] = 0;
 
    GetCurrentDirectoryW(MAX_PATH, work_dir);
    ptr = work_dir + lstrlenW( work_dir ) - 1;
    if (*ptr != '\\' && *ptr != '/')
        lstrcatW(work_dir, backslash);
    lstrcpyW(work_dir_subdir, work_dir);
    lstrcatW(work_dir_subdir, subdir);
 
    GetModuleFileNameW(NULL, app_manifest_path, sizeof(app_manifest_path)/sizeof(WCHAR));
    lstrcpyW(app_manifest_path+lstrlenW(app_manifest_path), dot_manifest);
}

Referenced by START_TEST().

kernel32_find()

static void kernel32_find ( ULONG  section, const char *  string_to_find, BOOL  should_find, int  line  )

static

Definition at line 2333 of file actctx.c.

{
    UNICODE_STRING string_to_findW;
    ACTCTX_SECTION_KEYED_DATA data;
    BOOL ret;
    DWORD err;
 
    pRtlCreateUnicodeStringFromAsciiz(&string_to_findW, string_to_find);
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    SetLastError(0);
    ret = pFindActCtxSectionStringA(0, NULL, section, string_to_find, &data);
    err = GetLastError();
    ok_(__FILE__, line)(ret == should_find,
        "FindActCtxSectionStringA: expected ret = %u, got %u\n", should_find, ret);
    ok_(__FILE__, line)(err == (should_find ? ERROR_SUCCESS : ERROR_SXS_KEY_NOT_FOUND),
        "FindActCtxSectionStringA: unexpected error %u\n", err);
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    SetLastError(0);
    ret = pFindActCtxSectionStringW(0, NULL, section, string_to_findW.Buffer, &data);
    err = GetLastError();
    ok_(__FILE__, line)(ret == should_find,
        "FindActCtxSectionStringW: expected ret = %u, got %u\n", should_find, ret);
    ok_(__FILE__, line)(err == (should_find ? ERROR_SUCCESS : ERROR_SXS_KEY_NOT_FOUND),
        "FindActCtxSectionStringW: unexpected error %u\n", err);
 
    SetLastError(0);
    ret = pFindActCtxSectionStringA(0, NULL, section, string_to_find, NULL);
    err = GetLastError();
    ok_(__FILE__, line)(!ret,
        "FindActCtxSectionStringA: expected failure, got %u\n", ret);
    ok_(__FILE__, line)(err == ERROR_INVALID_PARAMETER,
        "FindActCtxSectionStringA: unexpected error %u\n", err);
 
    SetLastError(0);
    ret = pFindActCtxSectionStringW(0, NULL, section, string_to_findW.Buffer, NULL);
    err = GetLastError();
    ok_(__FILE__, line)(!ret,
        "FindActCtxSectionStringW: expected failure, got %u\n", ret);
    ok_(__FILE__, line)(err == ERROR_INVALID_PARAMETER,
        "FindActCtxSectionStringW: unexpected error %u\n", err);
 
    pRtlFreeUnicodeString(&string_to_findW);
}

Referenced by test_findsectionstring().

ntdll_find()

static void ntdll_find ( ULONG  section, const char *  string_to_find, BOOL  should_find, int  line  )

static

Definition at line 2383 of file actctx.c.

{
    UNICODE_STRING string_to_findW;
    ACTCTX_SECTION_KEYED_DATA data;
    NTSTATUS ret;
 
    pRtlCreateUnicodeStringFromAsciiz(&string_to_findW, string_to_find);
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pRtlFindActivationContextSectionString(0, NULL, section, &string_to_findW, &data);
    ok_(__FILE__, line)(ret == (should_find ? STATUS_SUCCESS : STATUS_SXS_KEY_NOT_FOUND),
        "RtlFindActivationContextSectionString: unexpected status 0x%x\n", ret);
 
    ret = pRtlFindActivationContextSectionString(0, NULL, section, &string_to_findW, NULL);
    ok_(__FILE__, line)(ret == (should_find ? STATUS_SUCCESS : STATUS_SXS_KEY_NOT_FOUND),
        "RtlFindActivationContextSectionString: unexpected status 0x%x\n", ret);
 
    pRtlFreeUnicodeString(&string_to_findW);
}

Referenced by test_findsectionstring().

NTSTATUS()

static NTSTATUS ( NTAPI *  pRtlFindActivationContextSectionString )

static

run_child_process()

static void run_child_process ( void  )

static

Definition at line 2438 of file actctx.c.

{
    char cmdline[MAX_PATH];
    char path[MAX_PATH];
    char **argv;
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    HANDLE file;
    FILETIME now;
    BOOL ret;
 
    GetModuleFileNameA(NULL, path, MAX_PATH);
    strcat(path, ".manifest");
    if(!create_manifest_file(path, manifest1, -1, NULL, NULL)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    si.cb = sizeof(si);
    winetest_get_mainargs( &argv );
    /* Vista+ seems to cache presence of .manifest files. Change last modified
       date to defeat the cache */
    file = CreateFileA(argv[0], FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE,
                       NULL, OPEN_EXISTING, 0, NULL);
    if (file != INVALID_HANDLE_VALUE) {
        GetSystemTimeAsFileTime(&now);
        SetFileTime(file, NULL, NULL, &now);
        CloseHandle(file);
    }
    sprintf(cmdline, "\"%s\" %s manifest1", argv[0], argv[1]);
    ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "Could not create process: %u\n", GetLastError());
    winetest_wait_child_process( pi.hProcess );
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
    DeleteFileA(path);
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

actctx

)

Definition at line 2922 of file actctx.c.

{
    int argc;
    char **argv;
 
    argc = winetest_get_mainargs(&argv);
 
    if (!init_funcs())
    {
        win_skip("Needed functions are not available\n");
        return;
    }
    init_paths();
 
    if(argc > 2 && !strcmp(argv[2], "manifest1")) {
        test_app_manifest();
        return;
    }
 
    test_actctx();
    test_create_fail();
    test_CreateActCtx();
    test_findsectionstring();
    test_ZombifyActCtx();
    run_child_process();
    test_compatibility();
}

strcmp_aw()

static int strcmp_aw ( LPCWSTR  strw, const char *  stra  )

static

Definition at line 472 of file actctx.c.

{
    WCHAR buf[1024];
 
    if (!stra) return 1;
    MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(WCHAR));
    return lstrcmpW(strw, buf);
}

Referenced by test_info_in_assembly().

strlen_aw()

static DWORD strlen_aw ( const char *  str )

static

Definition at line 481 of file actctx.c.

{
    return MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0) - 1;
}

Referenced by test_info_in_assembly().

strw()

static const char * strw ( LPCWSTR  x )

static

Definition at line 49 of file actctx.c.

{
    static char buffer[1024];
    char*       p = buffer;
 
    if (!x) return "(nil)";
    else while ((*p++ = *x++));
    return buffer;
}

Referenced by exec_fontname(), get_doc_string(), html_src_compare(), is_prefix_wa(), str_eq_wa(), strcmp_aw(), strcmp_wa(), stricmp_wa(), test_detailed_info(), test_HexFromBin(), test_info_in_assembly(), and wstr_contains().

test_actctx()

static void test_actctx ( void  )

static

Definition at line 1970 of file actctx.c.

{
    ULONG_PTR cookie;
    HANDLE handle;
    BOOL b;
 
    trace("default actctx\n");
 
    b = pGetCurrentActCtx(&handle);
    ok(handle == NULL, "handle = %p, expected NULL\n", handle);
    ok(b, "GetCurrentActCtx failed: %u\n", GetLastError());
    if(b) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info0, __LINE__);
        test_runlevel_info(handle, &runlevel_info0, __LINE__);
        pReleaseActCtx(handle);
    }
 
    /* test for whitespace handling in Eq ::= S? '=' S? */
    create_manifest_file("test1_1.manifest", manifest1_1, -1, NULL, NULL);
    handle = test_create("test1_1.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test1_1.manifest");
    pReleaseActCtx(handle);
 
    if(!create_manifest_file("test1.manifest", manifest1, -1, NULL, NULL)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    trace("manifest1\n");
 
    handle = test_create("test1.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test1.manifest");
    if(handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info1, __LINE__);
        test_info_in_assembly(handle, 1, &manifest1_info, __LINE__);
 
        if (pIsDebuggerPresent && !pIsDebuggerPresent())
        {
            /* CloseHandle will generate an exception if a debugger is present */
            b = CloseHandle(handle);
            ok(!b, "CloseHandle succeeded\n");
            ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError() == %u\n", GetLastError());
        }
 
        pReleaseActCtx(handle);
    }
 
    if(!create_manifest_file("test2.manifest", manifest2, -1, "testdep.manifest", testdep_manifest1)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    trace("manifest2 depmanifest1\n");
 
    handle = test_create("test2.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test2.manifest");
    DeleteFileA("testdep.manifest");
    if(handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info2, __LINE__);
        test_info_in_assembly(handle, 1, &manifest2_info, __LINE__);
        test_info_in_assembly(handle, 2, &depmanifest1_info, __LINE__);
        pReleaseActCtx(handle);
    }
 
    if(!create_manifest_file("test2-2.manifest", manifest2, -1, "testdep.manifest", testdep_manifest2)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    trace("manifest2 depmanifest2\n");
 
    handle = test_create("test2-2.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test2-2.manifest");
    DeleteFileA("testdep.manifest");
    if(handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info2, __LINE__);
        test_info_in_assembly(handle, 1, &manifest2_info, __LINE__);
        test_info_in_assembly(handle, 2, &depmanifest2_info, __LINE__);
        test_file_info(handle, 1, 0, testlib_dll, __LINE__);
        test_file_info(handle, 1, 1, testlib2_dll, __LINE__);
 
        b = pActivateActCtx(handle, &cookie);
        ok(b, "ActivateActCtx failed: %u\n", GetLastError());
        test_find_dll_redirection(handle, testlib_dll, 2, __LINE__);
        test_find_dll_redirection(handle, testlib2_dll, 2, __LINE__);
        b = pDeactivateActCtx(0, cookie);
        ok(b, "DeactivateActCtx failed: %u\n", GetLastError());
 
        pReleaseActCtx(handle);
    }
 
    trace("manifest2 depmanifest3\n");
 
    if(!create_manifest_file("test2-3.manifest", manifest2, -1, "testdep.manifest", testdep_manifest3)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    handle = test_create("test2-3.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test2-3.manifest");
    DeleteFileA("testdep.manifest");
    if(handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info2, __LINE__);
        test_info_in_assembly(handle, 1, &manifest2_info, __LINE__);
        test_info_in_assembly(handle, 2, &depmanifest3_info, __LINE__);
        test_file_info(handle, 1, 0, testlib_dll, __LINE__);
        test_file_info(handle, 1, 1, testlib2_dll, __LINE__);
 
        b = pActivateActCtx(handle, &cookie);
        ok(b, "ActivateActCtx failed: %u\n", GetLastError());
        test_find_dll_redirection(handle, testlib_dll, 2, __LINE__);
        test_find_dll_redirection(handle, testlib2_dll, 2, __LINE__);
        test_find_window_class(handle, wndClassW, 2, __LINE__);
        test_find_window_class(handle, wndClass2W, 2, __LINE__);
        b = pDeactivateActCtx(0, cookie);
        ok(b, "DeactivateActCtx failed: %u\n", GetLastError());
 
        pReleaseActCtx(handle);
    }
 
    trace("manifest3\n");
 
    if(!create_manifest_file("test3.manifest", manifest3, -1, NULL, NULL)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    handle = test_create("test3.manifest");
    ok(handle != INVALID_HANDLE_VALUE || broken(handle == INVALID_HANDLE_VALUE) /* XP pre-SP2, win2k3 w/o SP */,
        "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    if (handle == INVALID_HANDLE_VALUE)
        win_skip("Some activation context features not supported, skipping a test (possibly old XP/Win2k3 system\n");
    DeleteFileA("test3.manifest");
    if(handle != INVALID_HANDLE_VALUE) {
        static const WCHAR nameW[] = {'t','e','s','t','s','u','r','r','o','g','a','t','e',0};
        static const WCHAR versionW[] = {'v','2','.','0','.','5','0','7','2','7',0};
        static const WCHAR progidW[] = {'P','r','o','g','I','d','.','P','r','o','g','I','d',0};
        static const WCHAR clrprogidW[] = {'c','l','r','p','r','o','g','i','d',0};
 
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info1, __LINE__);
        test_info_in_assembly(handle, 1, &manifest3_info, __LINE__);
        test_file_info(handle, 0, 0, testlib_dll, __LINE__);
 
        b = pActivateActCtx(handle, &cookie);
        ok(b, "ActivateActCtx failed: %u\n", GetLastError());
        test_find_dll_redirection(handle, testlib_dll, 1, __LINE__);
        test_find_dll_redirection(handle, testlib_dll, 1, __LINE__);
        test_find_com_redirection(handle, &IID_CoTest, &IID_TlibTest, progidW, 1, __LINE__);
        test_find_com_redirection(handle, &IID_CoTest2, NULL, NULL, 1, __LINE__);
        test_find_com_redirection(handle, &CLSID_clrclass, &IID_TlibTest, clrprogidW, 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId", 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId.1", 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId.2", 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId.3", 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId.4", 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId.5", 1, __LINE__);
        test_find_progid_redirection(handle, &IID_CoTest, "ProgId.ProgId.6", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid.1", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid.2", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid.3", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid.4", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid.5", 1, __LINE__);
        test_find_progid_redirection(handle, &CLSID_clrclass, "clrprogid.6", 1, __LINE__);
        test_find_surrogate(handle, &IID_Iiface, nameW, versionW, 1, __LINE__);
        test_find_ifaceps_redirection(handle, &IID_Iifaceps, &IID_TlibTest4, &IID_Ibifaceps, NULL, 1, __LINE__);
        test_find_ifaceps_redirection(handle, &IID_Iifaceps2, &IID_TlibTest4, &IID_Ibifaceps, &IID_PS32, 1, __LINE__);
        test_find_ifaceps_redirection(handle, &IID_Iifaceps3, &IID_TlibTest4, &IID_Ibifaceps, NULL, 1, __LINE__);
        test_find_string_fail();
 
        b = pDeactivateActCtx(0, cookie);
        ok(b, "DeactivateActCtx failed: %u\n", GetLastError());
        pReleaseActCtx(handle);
    }
 
    trace("manifest6\n");
 
    if(create_manifest_file("test6.manifest", manifest6, -1, NULL, NULL)) {
        handle = test_create("test6.manifest");
        ok(handle != INVALID_HANDLE_VALUE || broken(handle == INVALID_HANDLE_VALUE) /* WinXP */,
            "Unexpected context handle %p.\n", handle);
        DeleteFileA("test6.manifest");
        DeleteFileA("testdep.manifest");
        if(handle != INVALID_HANDLE_VALUE)
        {
            test_runlevel_info(handle, &runlevel_info6, __LINE__);
            pReleaseActCtx(handle);
        }
    }
    else
        skip("Could not create manifest file 6\n");
 
    trace("manifest7\n");
 
    if(create_manifest_file("test7.manifest", manifest7, -1, NULL, NULL)) {
        handle = test_create("test7.manifest");
        ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
        DeleteFileA("test7.manifest");
        DeleteFileA("testdep.manifest");
        if(handle != INVALID_HANDLE_VALUE)
        {
            test_runlevel_info(handle, &runlevel_info7, __LINE__);
            pReleaseActCtx(handle);
        }
    }
    else
        skip("Could not create manifest file 7\n");
 
    trace("manifest8\n");
 
    if(create_manifest_file("test8.manifest", manifest8, -1, NULL, NULL)) {
        handle = test_create("test8.manifest");
        ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
        DeleteFileA("test8.manifest");
        DeleteFileA("testdep.manifest");
        if(handle != INVALID_HANDLE_VALUE)
        {
            test_runlevel_info(handle, &runlevel_info8, __LINE__);
            pReleaseActCtx(handle);
        }
    }
    else
        skip("Could not create manifest file 8\n");
 
    trace("manifest9\n");
 
    if(create_manifest_file("test9.manifest", manifest9, -1, NULL, NULL)) {
        handle = test_create("test9.manifest");
        ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
        DeleteFileA("test9.manifest");
        DeleteFileA("testdep.manifest");
        if(handle != INVALID_HANDLE_VALUE)
        {
            test_runlevel_info(handle, &runlevel_info9, __LINE__);
            pReleaseActCtx(handle);
        }
    }
    else
        skip("Could not create manifest file 9\n");
 
    trace("manifest4\n");
 
    if(!create_manifest_file("test4.manifest", manifest4, -1, NULL, NULL)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    handle = test_create("test4.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test4.manifest");
    DeleteFileA("testdep.manifest");
    if(handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info2, __LINE__);
        test_info_in_assembly(handle, 1, &manifest4_info, __LINE__);
        test_info_in_assembly(handle, 2, &manifest_comctrl_info, __LINE__);
        pReleaseActCtx(handle);
    }
 
    trace("manifest1 in subdir\n");
 
    CreateDirectoryW(work_dir_subdir, NULL);
    if (SetCurrentDirectoryW(work_dir_subdir))
    {
        if(!create_manifest_file("..\\test1.manifest", manifest1, -1, NULL, NULL)) {
            skip("Could not create manifest file\n");
            return;
        }
        handle = test_create("..\\test1.manifest");
        ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
        DeleteFileA("..\\test1.manifest");
        if(handle != INVALID_HANDLE_VALUE) {
            test_basic_info(handle, __LINE__);
            test_detailed_info(handle, &detailed_info1, __LINE__);
            test_info_in_assembly(handle, 1, &manifest1_info, __LINE__);
            pReleaseActCtx(handle);
        }
        SetCurrentDirectoryW(work_dir);
    }
    else
        skip("Couldn't change directory\n");
    RemoveDirectoryW(work_dir_subdir);
 
    trace("UTF-16 manifest1, with BOM\n");
    if(!create_wide_manifest("test1.manifest", manifest1, TRUE, FALSE)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    handle = test_create("test1.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test1.manifest");
    if (handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info1, __LINE__);
        test_info_in_assembly(handle, 1, &manifest1_info, __LINE__);
        pReleaseActCtx(handle);
    }
 
    trace("UTF-16 manifest1, reverse endian, with BOM\n");
    if(!create_wide_manifest("test1.manifest", manifest1, TRUE, TRUE)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    handle = test_create("test1.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test1.manifest");
    if (handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info1, __LINE__);
        test_info_in_assembly(handle, 1, &manifest1_info, __LINE__);
        pReleaseActCtx(handle);
    }
 
    test_wndclass_section();
    test_dllredirect_section();
    test_typelib_section();
    test_allowDelayedBinding();
}

Referenced by START_TEST().

test_allowDelayedBinding()

static void test_allowDelayedBinding ( void  )

static

Definition at line 1947 of file actctx.c.

{
    HANDLE handle;
 
    if (!create_manifest_file("test5.manifest", manifest5, -1, NULL, NULL)) {
        skip("Could not create manifest file\n");
        return;
    }
 
    handle = test_create("test5.manifest");
    if (handle == INVALID_HANDLE_VALUE) {
        win_skip("allowDelayedBinding attribute is not supported.\n");
        return;
    }
 
    DeleteFileA("test5.manifest");
    DeleteFileA("testdep.manifest");
    if (handle != INVALID_HANDLE_VALUE) {
        test_basic_info(handle, __LINE__);
        pReleaseActCtx(handle);
    }
}

Referenced by test_actctx().

test_app_manifest()

static void test_app_manifest ( void  )

static

Definition at line 2302 of file actctx.c.

{
    HANDLE handle;
    BOOL b;
 
    trace("child process manifest1\n");
 
    b = pGetCurrentActCtx(&handle);
    ok(handle == NULL, "handle != NULL\n");
    ok(b, "GetCurrentActCtx failed: %u\n", GetLastError());
    if(b) {
        test_basic_info(handle, __LINE__);
        test_detailed_info(handle, &detailed_info1_child, __LINE__);
        test_info_in_assembly(handle, 1, &manifest1_child_info, __LINE__);
        pReleaseActCtx(handle);
    }
}

Referenced by START_TEST().

test_basic_info()

static void test_basic_info ( HANDLE  handle, int  line  )

static

Definition at line 1327 of file actctx.c.

{
    ACTIVATION_CONTEXT_BASIC_INFORMATION basic;
    SIZE_T size;
    BOOL b;
 
    b = pQueryActCtxW(QUERY_ACTCTX_FLAG_NO_ADDREF, handle, NULL,
                          ActivationContextBasicInformation, &basic,
                          sizeof(basic), &size);
 
    ok_(__FILE__, line) (b,"ActivationContextBasicInformation failed\n");
    ok_(__FILE__, line) (size == sizeof(ACTIVATION_CONTEXT_BASIC_INFORMATION),"size mismatch\n");
    ok_(__FILE__, line) (basic.dwFlags == 0, "unexpected flags %x\n",basic.dwFlags);
    ok_(__FILE__, line) (basic.hActCtx == handle, "unexpected handle\n");
 
    b = pQueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX |
                      QUERY_ACTCTX_FLAG_NO_ADDREF, handle, NULL,
                          ActivationContextBasicInformation, &basic,
                          sizeof(basic), &size);
    if (handle)
    {
        ok_(__FILE__, line) (!b,"ActivationContextBasicInformation succeeded\n");
        ok_(__FILE__, line) (size == 0,"size mismatch\n");
        ok_(__FILE__, line) (GetLastError() == ERROR_INVALID_PARAMETER, "Wrong last error\n");
        ok_(__FILE__, line) (basic.dwFlags == 0, "unexpected flags %x\n",basic.dwFlags);
        ok_(__FILE__, line) (basic.hActCtx == handle, "unexpected handle\n");
    }
    else
    {
        ok_(__FILE__, line) (b,"ActivationContextBasicInformation failed\n");
        ok_(__FILE__, line) (size == sizeof(ACTIVATION_CONTEXT_BASIC_INFORMATION),"size mismatch\n");
        ok_(__FILE__, line) (basic.dwFlags == 0, "unexpected flags %x\n",basic.dwFlags);
        ok_(__FILE__, line) (basic.hActCtx == handle, "unexpected handle\n");
    }
}

Referenced by test_actctx(), test_allowDelayedBinding(), test_app_manifest(), and test_compatibility().

test_compatibility()

static void test_compatibility ( void  )

static

Definition at line 2800 of file actctx.c.

{
    HANDLE handle;
 
    /* No compat results returned */
    trace("manifest1\n");
    if(!create_manifest_file("test1.manifest", manifest1, -1, NULL, NULL))
    {
        skip("Could not create manifest file\n");
        return;
    }
    handle = test_create("test1.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("test1.manifest");
    if(handle != INVALID_HANDLE_VALUE)
    {
        char buffer[sizeof(COMPATIBILITY_CONTEXT_ELEMENT) * 2 + sizeof(DWORD)];
        SIZE_T size;
        BOOL b;
 
        memset(buffer, 0, sizeof(buffer));
        b = pQueryActCtxW(QUERY_ACTCTX_FLAG_NO_ADDREF, handle, NULL,
                          CompatibilityInformationInActivationContext, buffer,
                          sizeof(buffer), &size);
 
        if (!b && GetLastError() == ERROR_INVALID_PARAMETER)
        {
            win_skip("CompatibilityInformationInActivationContext not supported.\n");
            pReleaseActCtx(handle);
            return;
        }
 
        test_basic_info(handle, __LINE__);
        test_no_compat(handle, __LINE__);
        pReleaseActCtx(handle);
    }
 
    /* Still no compat results returned */
    trace("no_supportedOs\n");
    if(!create_manifest_file("no_supportedOs.manifest", compat_manifest_no_supportedOs, -1, NULL, NULL))
    {
        skip("Could not create manifest file\n");
        return;
    }
    handle = test_create("no_supportedOs.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("no_supportedOs.manifest");
    if(handle != INVALID_HANDLE_VALUE)
    {
        test_basic_info(handle, __LINE__);
        test_no_compat(handle, __LINE__);
        pReleaseActCtx(handle);
    }
 
    /* Just one result returned */
    trace("manifest_vista\n");
    if(!create_manifest_file("manifest_vista.manifest", compat_manifest_vista, -1, NULL, NULL))
    {
        skip("Could not create manifest file\n");
        return;
    }
    handle = test_create("manifest_vista.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("manifest_vista.manifest");
    if(handle != INVALID_HANDLE_VALUE)
    {
        static const GUID* expect_manifest[] =
        {
            &VISTA_COMPAT_GUID
        };
        test_basic_info(handle, __LINE__);
        test_with_compat(handle, 1, expect_manifest, __LINE__);
        pReleaseActCtx(handle);
    }
 
    /* Show that the order is retained */
    trace("manifest_vista_7_8_10_81\n");
    if(!create_manifest_file("manifest_vista_7_8_10_81.manifest", compat_manifest_vista_7_8_10_81, -1, NULL, NULL))
    {
        skip("Could not create manifest file\n");
        return;
    }
    handle = test_create("manifest_vista_7_8_10_81.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("manifest_vista_7_8_10_81.manifest");
    if(handle != INVALID_HANDLE_VALUE)
    {
        static const GUID* expect_manifest[] =
        {
            &VISTA_COMPAT_GUID,
            &WIN7_COMPAT_GUID,
            &WIN8_COMPAT_GUID,
            &WIN10_COMPAT_GUID,
            &WIN81_COMPAT_GUID,
        };
        test_basic_info(handle, __LINE__);
        test_with_compat(handle, 5, expect_manifest, __LINE__);
        pReleaseActCtx(handle);
    }
 
    /* Show that even unknown GUID's are stored */
    trace("manifest_other_guid\n");
    if(!create_manifest_file("manifest_other_guid.manifest", compat_manifest_other_guid, -1, NULL, NULL))
    {
        skip("Could not create manifest file\n");
        return;
    }
    handle = test_create("manifest_other_guid.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
    DeleteFileA("manifest_other_guid.manifest");
    if(handle != INVALID_HANDLE_VALUE)
    {
        static const GUID* expect_manifest[] =
        {
            &OTHER_COMPAT_GUID,
        };
        test_basic_info(handle, __LINE__);
        test_with_compat(handle, 1, expect_manifest, __LINE__);
        pReleaseActCtx(handle);
    }
}

Referenced by START_TEST().

test_create()

static HANDLE test_create ( const char *  file )

static

Definition at line 924 of file actctx.c.

{
    ACTCTXW actctx;
    HANDLE handle;
    WCHAR path[MAX_PATH];
 
    MultiByteToWideChar( CP_ACP, 0, file, -1, path, MAX_PATH );
    memset(&actctx, 0, sizeof(ACTCTXW));
    actctx.cbSize = sizeof(ACTCTXW);
    actctx.lpSource = path;
 
    handle = pCreateActCtxW(&actctx);
    /* to be tested outside of this helper, including last error */
    if (handle == INVALID_HANDLE_VALUE) return handle;
 
    ok(actctx.cbSize == sizeof(actctx), "actctx.cbSize=%d\n", actctx.cbSize);
    ok(actctx.dwFlags == 0, "actctx.dwFlags=%d\n", actctx.dwFlags);
    ok(actctx.lpSource == path, "actctx.lpSource=%p\n", actctx.lpSource);
    ok(actctx.wProcessorArchitecture == 0,
       "actctx.wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
    ok(actctx.wLangId == 0, "actctx.wLangId=%d\n", actctx.wLangId);
    ok(actctx.lpAssemblyDirectory == NULL,
       "actctx.lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
    ok(actctx.lpResourceName == NULL, "actctx.lpResourceName=%p\n", actctx.lpResourceName);
    ok(actctx.lpApplicationName == NULL, "actctx.lpApplicationName=%p\n",
       actctx.lpApplicationName);
    ok(actctx.hModule == NULL, "actctx.hModule=%p\n", actctx.hModule);
 
    return handle;
}

test_create_and_fail()

static void test_create_and_fail ( const char *  manifest, const char *  depmanifest, int  todo, BOOL  is_broken  )

static

Definition at line 955 of file actctx.c.

{
    ACTCTXW actctx;
    HANDLE handle;
    WCHAR path[MAX_PATH];
 
    MultiByteToWideChar( CP_ACP, 0, "bad.manifest", -1, path, MAX_PATH );
    memset(&actctx, 0, sizeof(ACTCTXW));
    actctx.cbSize = sizeof(ACTCTXW);
    actctx.lpSource = path;
 
    create_manifest_file("bad.manifest", manifest, -1, "testdep.manifest", depmanifest);
    handle = pCreateActCtxW(&actctx);
    todo_wine_if(todo)
    {
        if (is_broken)
            ok(broken(handle != INVALID_HANDLE_VALUE) || handle == INVALID_HANDLE_VALUE,
                "Unexpected context handle %p.\n", handle);
        else
            ok(handle == INVALID_HANDLE_VALUE, "Unexpected context handle %p.\n", handle);
 
        if (handle == INVALID_HANDLE_VALUE)
            ok(GetLastError() == ERROR_SXS_CANT_GEN_ACTCTX, "Unexpected error %d.\n", GetLastError());
    }
    if (handle != INVALID_HANDLE_VALUE) pReleaseActCtx( handle );
    DeleteFileA("bad.manifest");
    DeleteFileA("testdep.manifest");
}

Referenced by test_create_fail().

test_create_fail()

static void test_create_fail ( void  )

static

Definition at line 1004 of file actctx.c.

{
    ACTCTXW actctx;
    HANDLE handle;
    WCHAR path[MAX_PATH];
 
    MultiByteToWideChar( CP_ACP, 0, "nonexistent.manifest", -1, path, MAX_PATH );
    memset(&actctx, 0, sizeof(ACTCTXW));
    actctx.cbSize = sizeof(ACTCTXW);
    actctx.lpSource = path;
 
    handle = pCreateActCtxW(&actctx);
    ok(handle == INVALID_HANDLE_VALUE, "handle != INVALID_HANDLE_VALUE\n");
    ok(GetLastError() == ERROR_FILE_NOT_FOUND, "GetLastError == %u\n", GetLastError());
 
    trace("wrong_manifest1\n");
    test_create_and_fail(wrong_manifest1, NULL, 0, FALSE);
    trace("wrong_manifest2\n");
    test_create_and_fail(wrong_manifest2, NULL, 0, FALSE);
    trace("wrong_manifest3\n");
    test_create_and_fail(wrong_manifest3, NULL, 1, FALSE);
    trace("wrong_manifest4\n");
    test_create_and_fail(wrong_manifest4, NULL, 1, FALSE);
    trace("wrong_manifest5\n");
    test_create_and_fail(wrong_manifest5, NULL, 0, FALSE);
    trace("wrong_manifest6\n");
    test_create_and_fail(wrong_manifest6, NULL, 0, FALSE);
    trace("wrong_manifest7\n");
    test_create_and_fail(wrong_manifest7, NULL, 1, FALSE);
    trace("wrong_manifest8\n");
    test_create_and_fail(wrong_manifest8, NULL, 0, FALSE);
    trace("wrong_manifest9\n");
    test_create_and_fail(wrong_manifest9, NULL, 0, TRUE /* WinXP */);
    trace("wrong_manifest10\n");
    test_create_and_fail(wrong_manifest10, NULL, 0, TRUE /* WinXP */);
    trace("UTF-16 manifest1 without BOM\n");
    test_create_wide_and_fail(manifest1, FALSE );
    trace("manifest2\n");
    test_create_and_fail(manifest2, NULL, 0, FALSE);
    trace("manifest2+depmanifest1\n");
    test_create_and_fail(manifest2, wrong_depmanifest1, 0, FALSE);
}

Referenced by START_TEST().

test_create_wide_and_fail()

static void test_create_wide_and_fail ( const char *  manifest, BOOL  fBOM  )

static

Definition at line 984 of file actctx.c.

{
    ACTCTXW actctx;
    HANDLE handle;
    WCHAR path[MAX_PATH];
 
    MultiByteToWideChar( CP_ACP, 0, "bad.manifest", -1, path, MAX_PATH );
    memset(&actctx, 0, sizeof(ACTCTXW));
    actctx.cbSize = sizeof(ACTCTXW);
    actctx.lpSource = path;
 
    create_wide_manifest("bad.manifest", manifest, fBOM, FALSE);
    handle = pCreateActCtxW(&actctx);
    ok(handle == INVALID_HANDLE_VALUE, "handle != INVALID_HANDLE_VALUE\n");
    ok(GetLastError() == ERROR_SXS_CANT_GEN_ACTCTX, "GetLastError == %u\n", GetLastError());
 
    if (handle != INVALID_HANDLE_VALUE) pReleaseActCtx( handle );
    DeleteFileA("bad.manifest");
}

Referenced by test_create_fail().

test_CreateActCtx()

static void test_CreateActCtx ( void  )

static

Definition at line 2524 of file actctx.c.

{
    CHAR path[MAX_PATH], dir[MAX_PATH];
    ACTCTXA actctx;
    HANDLE handle;
 
    GetTempPathA(sizeof(path)/sizeof(CHAR), path);
    strcat(path, "main_wndcls.manifest");
 
    write_manifest("testdep1.manifest", manifest_wndcls1);
    write_manifest("testdep2.manifest", manifest_wndcls2);
    write_manifest("main_wndcls.manifest", manifest_wndcls_main);
 
    memset(&actctx, 0, sizeof(ACTCTXA));
    actctx.cbSize = sizeof(ACTCTXA);
    actctx.lpSource = path;
 
    /* create using lpSource without specified directory */
    handle = pCreateActCtxA(&actctx);
    ok(handle != INVALID_HANDLE_VALUE, "failed to generate context, error %u\n", GetLastError());
    pReleaseActCtx(handle);
 
    /* with specified directory, that doesn't contain dependent assembly */
    GetWindowsDirectoryA(dir, sizeof(dir)/sizeof(CHAR));
 
    memset(&actctx, 0, sizeof(ACTCTXA));
    actctx.cbSize = sizeof(ACTCTXA);
    actctx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
    actctx.lpAssemblyDirectory = dir;
    actctx.lpSource = path;
 
    SetLastError(0xdeadbeef);
    handle = pCreateActCtxA(&actctx);
todo_wine {
    ok(handle == INVALID_HANDLE_VALUE, "got handle %p\n", handle);
    ok(GetLastError() == ERROR_SXS_CANT_GEN_ACTCTX, "got error %d\n", GetLastError());
}
    if (handle != INVALID_HANDLE_VALUE) pReleaseActCtx(handle);
 
    delete_manifest_file("main_wndcls.manifest");
    delete_manifest_file("testdep1.manifest");
    delete_manifest_file("testdep2.manifest");
 
    /* ACTCTX_FLAG_HMODULE_VALID but hModule is not set */
    memset(&actctx, 0, sizeof(ACTCTXA));
    actctx.cbSize = sizeof(ACTCTXA);
    actctx.dwFlags = ACTCTX_FLAG_HMODULE_VALID;
    SetLastError(0xdeadbeef);
    handle = pCreateActCtxA(&actctx);
    ok(handle == INVALID_HANDLE_VALUE, "got handle %p\n", handle);
todo_wine
    ok(GetLastError() == ERROR_SXS_CANT_GEN_ACTCTX || broken(GetLastError() == ERROR_NOT_ENOUGH_MEMORY) /* XP, win2k3 */,
        "got error %d\n", GetLastError());
 
    /* create from HMODULE - resource doesn't exist, lpSource is set */
    memset(&actctx, 0, sizeof(ACTCTXA));
    actctx.cbSize = sizeof(ACTCTXA);
    actctx.dwFlags = ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_HMODULE_VALID;
    actctx.lpSource = "dummyfile.dll";
    actctx.lpResourceName = MAKEINTRESOURCEA(20);
    actctx.hModule = GetModuleHandleA(NULL);
 
    SetLastError(0xdeadbeef);
    handle = pCreateActCtxA(&actctx);
    ok(handle == INVALID_HANDLE_VALUE, "got handle %p\n", handle);
    ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND, "got error %d\n", GetLastError());
 
    /* load manifest from lpAssemblyDirectory directory */
    write_manifest("testdir.manifest", manifest1);
    GetTempPathA(sizeof(path)/sizeof(path[0]), path);
    SetCurrentDirectoryA(path);
    strcat(path, "assembly_dir");
    strcpy(dir, path);
    strcat(path, "\\testdir.manifest");
 
    memset(&actctx, 0, sizeof(actctx));
    actctx.cbSize = sizeof(actctx);
    actctx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
    actctx.lpSource = "testdir.manifest";
    actctx.lpAssemblyDirectory = dir;
 
    SetLastError(0xdeadbeef);
    handle = pCreateActCtxA(&actctx);
    ok(handle == INVALID_HANDLE_VALUE, "got handle %p\n", handle);
    ok(GetLastError()==ERROR_PATH_NOT_FOUND ||
            broken(GetLastError()==ERROR_FILE_NOT_FOUND) /* WinXP */,
            "got error %d\n", GetLastError());
 
    CreateDirectoryA(dir, NULL);
    memset(&actctx, 0, sizeof(actctx));
    actctx.cbSize = sizeof(actctx);
    actctx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
    actctx.lpSource = "testdir.manifest";
    actctx.lpAssemblyDirectory = dir;
 
    SetLastError(0xdeadbeef);
    handle = pCreateActCtxA(&actctx);
    ok(handle == INVALID_HANDLE_VALUE, "got handle %p\n", handle);
    ok(GetLastError() == ERROR_FILE_NOT_FOUND, "got error %d\n", GetLastError());
    SetCurrentDirectoryW(work_dir);
 
    write_manifest("assembly_dir\\testdir.manifest", manifest1);
    memset(&actctx, 0, sizeof(actctx));
    actctx.cbSize = sizeof(actctx);
    actctx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
    actctx.lpSource = "testdir.manifest";
    actctx.lpAssemblyDirectory = dir;
 
    handle = pCreateActCtxA(&actctx);
    ok(handle != INVALID_HANDLE_VALUE, "got handle %p\n", handle);
    pReleaseActCtx(handle);
 
    memset(&actctx, 0, sizeof(actctx));
    actctx.cbSize = sizeof(actctx);
    actctx.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
    actctx.lpSource = path;
    actctx.lpAssemblyDirectory = dir;
 
    handle = pCreateActCtxA(&actctx);
    ok(handle != INVALID_HANDLE_VALUE, "got handle %p\n", handle);
    pReleaseActCtx(handle);
 
    delete_manifest_file("testdir.manifest");
    delete_manifest_file("assembly_dir\\testdir.manifest");
    RemoveDirectoryA(dir);
}

Referenced by START_TEST().

test_detailed_info()

static void test_detailed_info ( HANDLE  handle, const detailed_info_t *  exinfo, int  line  )

static

Definition at line 575 of file actctx.c.

{
    ACTIVATION_CONTEXT_DETAILED_INFORMATION detailed_info_tmp, *detailed_info;
    SIZE_T size, exsize, retsize;
    BOOL b;
 
    exsize = sizeof(ACTIVATION_CONTEXT_DETAILED_INFORMATION)
        + (exinfo->root_manifest_path ? (lstrlenW(exinfo->root_manifest_path)+1)*sizeof(WCHAR):0)
        + (exinfo->app_dir ? (lstrlenW(exinfo->app_dir)+1)*sizeof(WCHAR) : 0);
 
    if(exsize != sizeof(ACTIVATION_CONTEXT_DETAILED_INFORMATION)) {
        size = 0xdeadbeef;
        b = pQueryActCtxW(0, handle, NULL,
                          ActivationContextDetailedInformation, &detailed_info_tmp,
                          sizeof(detailed_info_tmp), &size);
        ok_(__FILE__, line)(!b, "QueryActCtx succeeded\n");
        ok_(__FILE__, line)(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetLastError() = %u\n", GetLastError());
        ok_(__FILE__, line)(size == exsize, "size=%ld, expected %ld\n", size, exsize);
    }else {
        size = sizeof(ACTIVATION_CONTEXT_DETAILED_INFORMATION);
    }
 
    detailed_info = HeapAlloc(GetProcessHeap(), 0, size);
    memset(detailed_info, 0xfe, size);
    b = pQueryActCtxW(0, handle, NULL,
                      ActivationContextDetailedInformation, detailed_info,
                      size, &retsize);
    ok_(__FILE__, line)(b, "QueryActCtx failed: %u\n", GetLastError());
    ok_(__FILE__, line)(retsize == exsize, "size=%ld, expected %ld\n", retsize, exsize);
 
    ok_(__FILE__, line)(detailed_info->dwFlags == 0, "detailed_info->dwFlags=%x\n", detailed_info->dwFlags);
    ok_(__FILE__, line)(detailed_info->ulFormatVersion == exinfo->format_version,
       "detailed_info->ulFormatVersion=%u, expected %u\n", detailed_info->ulFormatVersion,
       exinfo->format_version);
    ok_(__FILE__, line)(exinfo->assembly_cnt_min <= detailed_info->ulAssemblyCount &&
       detailed_info->ulAssemblyCount <= exinfo->assembly_cnt_max,
       "detailed_info->ulAssemblyCount=%u, expected between %u and %u\n", detailed_info->ulAssemblyCount,
       exinfo->assembly_cnt_min, exinfo->assembly_cnt_max);
    ok_(__FILE__, line)(detailed_info->ulRootManifestPathType == exinfo->root_manifest_type,
       "detailed_info->ulRootManifestPathType=%u, expected %u\n",
       detailed_info->ulRootManifestPathType, exinfo->root_manifest_type);
    ok_(__FILE__, line)(detailed_info->ulRootManifestPathChars ==
       (exinfo->root_manifest_path ? lstrlenW(exinfo->root_manifest_path) : 0),
       "detailed_info->ulRootManifestPathChars=%u, expected %u\n",
       detailed_info->ulRootManifestPathChars,
       exinfo->root_manifest_path ?lstrlenW(exinfo->root_manifest_path) : 0);
    ok_(__FILE__, line)(detailed_info->ulRootConfigurationPathType == exinfo->root_config_type,
       "detailed_info->ulRootConfigurationPathType=%u, expected %u\n",
       detailed_info->ulRootConfigurationPathType, exinfo->root_config_type);
    ok_(__FILE__, line)(detailed_info->ulRootConfigurationPathChars == 0,
       "detailed_info->ulRootConfigurationPathChars=%d\n", detailed_info->ulRootConfigurationPathChars);
    ok_(__FILE__, line)(detailed_info->ulAppDirPathType == exinfo->app_dir_type,
       "detailed_info->ulAppDirPathType=%u, expected %u\n", detailed_info->ulAppDirPathType,
       exinfo->app_dir_type);
    ok_(__FILE__, line)(detailed_info->ulAppDirPathChars == (exinfo->app_dir ? lstrlenW(exinfo->app_dir) : 0),
       "detailed_info->ulAppDirPathChars=%u, expected %u\n",
       detailed_info->ulAppDirPathChars, exinfo->app_dir ? lstrlenW(exinfo->app_dir) : 0);
    if(exinfo->root_manifest_path) {
        ok_(__FILE__, line)(detailed_info->lpRootManifestPath != NULL, "detailed_info->lpRootManifestPath == NULL\n");
        if(detailed_info->lpRootManifestPath)
            ok_(__FILE__, line)(!lstrcmpiW(detailed_info->lpRootManifestPath, exinfo->root_manifest_path),
               "unexpected detailed_info->lpRootManifestPath\n");
    }else {
        ok_(__FILE__, line)(detailed_info->lpRootManifestPath == NULL, "detailed_info->lpRootManifestPath != NULL\n");
    }
    ok_(__FILE__, line)(detailed_info->lpRootConfigurationPath == NULL,
       "detailed_info->lpRootConfigurationPath=%p\n", detailed_info->lpRootConfigurationPath);
    if(exinfo->app_dir) {
        ok_(__FILE__, line)(detailed_info->lpAppDirPath != NULL, "detailed_info->lpAppDirPath == NULL\n");
        if(detailed_info->lpAppDirPath)
            ok_(__FILE__, line)(!lstrcmpiW(exinfo->app_dir, detailed_info->lpAppDirPath),
               "unexpected detailed_info->lpAppDirPath\n%s\n",strw(detailed_info->lpAppDirPath));
    }else {
        ok_(__FILE__, line)(detailed_info->lpAppDirPath == NULL, "detailed_info->lpAppDirPath != NULL\n");
    }
 
    HeapFree(GetProcessHeap(), 0, detailed_info);
}

Referenced by test_actctx(), and test_app_manifest().

test_dllredirect_section()

static void test_dllredirect_section ( void  )

static

Definition at line 1823 of file actctx.c.

{
    static const WCHAR testlib1W[] = {'t','e','s','t','l','i','b','1','.','d','l','l',0};
    static const WCHAR testlib2W[] = {'t','e','s','t','l','i','b','2','.','d','l','l',0};
    ACTCTX_SECTION_KEYED_DATA data, data2;
    struct strsection_header *section;
    ULONG_PTR cookie;
    HANDLE handle;
    BOOL ret;
 
    /* use two dependent manifests, 4 'files' total */
    create_manifest_file("testdep1.manifest", manifest_wndcls1, -1, NULL, NULL);
    create_manifest_file("testdep2.manifest", manifest_wndcls2, -1, NULL, NULL);
    create_manifest_file("main_wndcls.manifest", manifest_wndcls_main, -1, NULL, NULL);
 
    handle = test_create("main_wndcls.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
 
    DeleteFileA("testdep1.manifest");
    DeleteFileA("testdep2.manifest");
    DeleteFileA("main_wndcls.manifest");
 
    ret = pActivateActCtx(handle, &cookie);
    ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
 
    memset(&data, 0, sizeof(data));
    memset(&data2, 0, sizeof(data2));
    data.cbSize = sizeof(data);
    data2.cbSize = sizeof(data2);
 
    /* get data for two files from different assemblies */
    ret = pFindActCtxSectionStringW(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    testlib1W, &data);
    ok(ret, "got %d\n", ret);
    ret = pFindActCtxSectionStringW(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    testlib2W, &data2);
    ok(ret, "got %d\n", ret);
 
    section = (struct strsection_header*)data.lpSectionBase;
    ok(section->count == 4, "got %d\n", section->count);
    ok(section->size == sizeof(*section), "got %d\n", section->size);
 
    /* For both string same section is returned, meaning it's one dll redirect section per context */
    ok(data.lpSectionBase == data2.lpSectionBase, "got %p, %p\n", data.lpSectionBase, data2.lpSectionBase);
    ok(data.ulSectionTotalLength == data2.ulSectionTotalLength, "got %u, %u\n", data.ulSectionTotalLength,
        data2.ulSectionTotalLength);
 
    ret = pDeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
 
    pReleaseActCtx(handle);
}

Referenced by test_actctx().

test_file_info()

static void test_file_info ( HANDLE  handle, ULONG  assid, ULONG  fileid, LPCWSTR  filename, int  line  )

static

Definition at line 829 of file actctx.c.

{
    ASSEMBLY_FILE_DETAILED_INFORMATION *info, info_tmp;
    ACTIVATION_CONTEXT_QUERY_INDEX index = {assid, fileid};
    SIZE_T size, exsize;
    BOOL b;
 
    exsize = sizeof(ASSEMBLY_FILE_DETAILED_INFORMATION)
        +(lstrlenW(filename)+1)*sizeof(WCHAR);
 
    size = 0xdeadbeef;
    b = pQueryActCtxW(0, handle, &index,
                      FileInformationInAssemblyOfAssemblyInActivationContext, &info_tmp,
                      sizeof(info_tmp), &size);
    ok_(__FILE__, line)(!b, "QueryActCtx succeeded\n");
    ok_(__FILE__, line)(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetLastError() = %u\n", GetLastError());
    ok_(__FILE__, line)(size == exsize, "size=%lu, expected %lu\n", size, exsize);
 
    if(size == 0xdeadbeef)
    {
        skip("bad size\n");
        return;
    }
 
    info = HeapAlloc(GetProcessHeap(), 0, size);
    memset(info, 0xfe, size);
 
    b = pQueryActCtxW(0, handle, &index,
                      FileInformationInAssemblyOfAssemblyInActivationContext, info, size, &size);
    ok_(__FILE__, line)(b, "QueryActCtx failed: %u\n", GetLastError());
    ok_(__FILE__, line)(!size, "size=%lu, expected 0\n", size);
 
    ok_(__FILE__, line)(info->ulFlags == 2, "info->ulFlags=%x, expected 2\n", info->ulFlags);
    ok_(__FILE__, line)(info->ulFilenameLength == lstrlenW(filename)*sizeof(WCHAR),
       "info->ulFilenameLength=%u, expected %u*sizeof(WCHAR)\n",
       info->ulFilenameLength, lstrlenW(filename));
    ok_(__FILE__, line)(info->ulPathLength == 0, "info->ulPathLength=%u\n", info->ulPathLength);
    ok_(__FILE__, line)(info->lpFileName != NULL, "info->lpFileName == NULL\n");
    if(info->lpFileName)
        ok_(__FILE__, line)(!lstrcmpiW(info->lpFileName, filename), "unexpected info->lpFileName\n");
    ok_(__FILE__, line)(info->lpFilePath == NULL, "info->lpFilePath != NULL\n");
    HeapFree(GetProcessHeap(), 0, info);
}

test_find_com_redirection()

static void test_find_com_redirection ( HANDLE  handle, const GUID *  clsid, const GUID *  tlid, const WCHAR *  progid, ULONG  exid, int  line  )

static

Definition at line 1414 of file actctx.c.

{
    struct comclassredirect_data *comclass, *comclass2;
    ACTCTX_SECTION_KEYED_DATA data, data2;
    struct guidsection_header *header;
    BOOL ret;
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionGuid(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                                    clsid, &data);
    if (!ret)
    {
        skip("failed for guid %s\n", wine_dbgstr_guid(clsid));
        return;
    }
    ok_(__FILE__, line)(ret, "FindActCtxSectionGuid failed: %u\n", GetLastError());
 
    comclass = (struct comclassredirect_data*)data.lpData;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(comclass->size == sizeof(*comclass), "got %d for header size\n", comclass->size);
    if (data.lpData && comclass->size == sizeof(*comclass))
    {
        WCHAR *ptr;
        ULONG len;
 
        ok_(__FILE__, line)(comclass->res == 0, "got res as %d\n", comclass->res);
        ok_(__FILE__, line)(comclass->res1[0] == 0, "got res1[0] as %02x\n", comclass->res1[0]);
        ok_(__FILE__, line)(comclass->res1[1] == 0, "got res1[1] as %02x\n", comclass->res1[1]);
        ok_(__FILE__, line)(comclass->model == ThreadingModel_Neutral, "got model %d\n", comclass->model);
        ok_(__FILE__, line)(IsEqualGUID(&comclass->clsid, clsid), "got wrong clsid %s\n", wine_dbgstr_guid(&comclass->clsid));
        ok_(__FILE__, line)(IsEqualGUID(&comclass->clsid2, clsid), "got wrong clsid2 %s\n", wine_dbgstr_guid(&comclass->clsid2));
        if (tlid)
            ok_(__FILE__, line)(IsEqualGUID(&comclass->tlid, tlid), "got wrong tlid %s\n", wine_dbgstr_guid(&comclass->tlid));
        ok_(__FILE__, line)(comclass->name_len > 0, "got modulename len %d\n", comclass->name_len);
 
        if (progid)
        {
            len = comclass->size + comclass->clrdata_len;
            ok_(__FILE__, line)(comclass->progid_offset == len, "got progid offset %d, expected %d\n", comclass->progid_offset, len);
        }
        else
            ok_(__FILE__, line)(comclass->progid_offset == 0, "got progid offset %d, expected 0\n", comclass->progid_offset);
 
        if (comclass->progid_offset)
        {
            ptr = (WCHAR*)((BYTE*)comclass + comclass->progid_offset);
            ok_(__FILE__, line)(!lstrcmpW(ptr, progid), "got wrong progid %s, expected %s\n", wine_dbgstr_w(ptr), wine_dbgstr_w(progid));
            ok_(__FILE__, line)(lstrlenW(progid)*sizeof(WCHAR) == comclass->progid_len,
                "got progid name length %d\n", comclass->progid_len);
        }
 
        /* data length is simply header length + string data length including nulls */
        len = comclass->size + comclass->clrdata_len;
        if (comclass->progid_len) len += comclass->progid_len + sizeof(WCHAR);
        ok_(__FILE__, line)(data.ulLength == len, "got wrong data length %d, expected %d\n", data.ulLength, len);
 
        /* keyed data structure doesn't include module name, it's available from section data */
        ok_(__FILE__, line)(data.ulSectionTotalLength > comclass->name_offset, "got wrong offset %d\n", comclass->name_offset);
 
        /* check misc fields are set */
        if (comclass->miscmask)
        {
            if (comclass->miscmask & MiscStatus)
                ok_(__FILE__, line)(comclass->miscstatus != 0, "got miscstatus 0x%08x\n", comclass->miscstatus);
            if (comclass->miscmask & MiscStatusIcon)
                ok_(__FILE__, line)(comclass->miscstatusicon != 0, "got miscstatusicon 0x%08x\n", comclass->miscstatusicon);
            if (comclass->miscmask & MiscStatusContent)
                ok_(__FILE__, line)(comclass->miscstatuscontent != 0, "got miscstatuscontent 0x%08x\n", comclass->miscstatuscontent);
            if (comclass->miscmask & MiscStatusThumbnail)
                ok_(__FILE__, line)(comclass->miscstatusthumbnail != 0, "got miscstatusthumbnail 0x%08x\n", comclass->miscstatusthumbnail);
            if (comclass->miscmask & MiscStatusDocPrint)
                ok_(__FILE__, line)(comclass->miscstatusdocprint != 0, "got miscstatusdocprint 0x%08x\n", comclass->miscstatusdocprint);
        }
 
        /* part used for clrClass only */
        if (comclass->clrdata_len)
        {
            static const WCHAR mscoreeW[] = {'M','S','C','O','R','E','E','.','D','L','L',0};
            static const WCHAR mscoree2W[] = {'m','s','c','o','r','e','e','.','d','l','l',0};
            struct clrclass_data *clrclass;
            WCHAR *ptrW;
 
            clrclass = (struct clrclass_data*)((BYTE*)data.lpData + comclass->clrdata_offset);
            ok_(__FILE__, line)(clrclass->size == sizeof(*clrclass), "clrclass: got size %d\n", clrclass->size);
            ok_(__FILE__, line)(clrclass->res[0] == 0, "clrclass: got res[0]=0x%08x\n", clrclass->res[0]);
            ok_(__FILE__, line)(clrclass->res[1] == 2, "clrclass: got res[1]=0x%08x\n", clrclass->res[1]);
            ok_(__FILE__, line)(clrclass->module_len == lstrlenW(mscoreeW)*sizeof(WCHAR), "clrclass: got module len %d\n", clrclass->module_len);
            ok_(__FILE__, line)(clrclass->module_offset > 0, "clrclass: got module offset %d\n", clrclass->module_offset);
 
            ok_(__FILE__, line)(clrclass->name_len > 0, "clrclass: got name len %d\n", clrclass->name_len);
            ok_(__FILE__, line)(clrclass->name_offset == clrclass->size, "clrclass: got name offset %d\n", clrclass->name_offset);
            ok_(__FILE__, line)(clrclass->version_len > 0, "clrclass: got version len %d\n", clrclass->version_len);
            ok_(__FILE__, line)(clrclass->version_offset > 0, "clrclass: got version offset %d\n", clrclass->version_offset);
 
            ok_(__FILE__, line)(clrclass->res2[0] == 0, "clrclass: got res2[0]=0x%08x\n", clrclass->res2[0]);
            ok_(__FILE__, line)(clrclass->res2[1] == 0, "clrclass: got res2[1]=0x%08x\n", clrclass->res2[1]);
 
            /* clrClass uses mscoree.dll as module name, but in two variants - comclass data points to module name
               in lower case, clsclass subsection - in upper case */
            ok_(__FILE__, line)(comclass->name_len == lstrlenW(mscoree2W)*sizeof(WCHAR), "clrclass: got com name len %d\n", comclass->name_len);
            ok_(__FILE__, line)(comclass->name_offset > 0, "clrclass: got name offset %d\n", clrclass->name_offset);
 
            ptrW = (WCHAR*)((BYTE*)data.lpSectionBase + comclass->name_offset);
            ok_(__FILE__, line)(!lstrcmpW(ptrW, mscoreeW), "clrclass: module name %s\n", wine_dbgstr_w(ptrW));
 
            ptrW = (WCHAR*)((BYTE*)data.lpSectionBase + clrclass->module_offset);
            ok_(__FILE__, line)(!lstrcmpW(ptrW, mscoree2W), "clrclass: module name2 %s\n", wine_dbgstr_w(ptrW));
        }
    }
 
    header = (struct guidsection_header*)data.lpSectionBase;
    ok_(__FILE__, line)(data.lpSectionGlobalData == ((BYTE*)header + header->names_offset), "data.lpSectionGlobalData == NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == header->names_len, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n",
       data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == NULL, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
 
    /* generated guid for this class works as key guid in search */
    memset(&data2, 0xfe, sizeof(data2));
    data2.cbSize = sizeof(data2);
    ret = pFindActCtxSectionGuid(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                                    &comclass->alias, &data2);
    ok_(__FILE__, line)(ret, "FindActCtxSectionGuid failed: %u\n", GetLastError());
 
    comclass2 = (struct comclassredirect_data*)data2.lpData;
    ok_(__FILE__, line)(comclass->size == comclass2->size, "got wrong data length %d, expected %d\n", comclass2->size, comclass->size);
    ok_(__FILE__, line)(!memcmp(comclass, comclass2, comclass->size), "got wrong data\n");
}

Referenced by test_actctx().

test_find_dll_redirection()

static void test_find_dll_redirection ( HANDLE  handle, LPCWSTR  libname, ULONG  exid, int  line  )

static

Definition at line 1127 of file actctx.c.

{
    ACTCTX_SECTION_KEYED_DATA data;
    BOOL ret;
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionStringW(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    libname, &data);
    ok_(__FILE__, line)(ret, "FindActCtxSectionStringW failed: %u\n", GetLastError());
    if (!ret) return;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(data.ulLength == 20, "data.ulLength=%u\n", data.ulLength);
 
    if (data.lpData)
    {
        struct dllredirect_data *dlldata = (struct dllredirect_data*)data.lpData;
        ok_(__FILE__, line)(dlldata->size == data.ulLength, "got wrong size %d\n", dlldata->size);
        ok_(__FILE__, line)(dlldata->unk == 2, "got wrong field value %d\n", dlldata->unk);
        ok_(__FILE__, line)(dlldata->res[0] == 0, "got wrong res[0] value %d\n", dlldata->res[0]);
        ok_(__FILE__, line)(dlldata->res[1] == 0, "got wrong res[1] value %d\n", dlldata->res[1]);
        ok_(__FILE__, line)(dlldata->res[2] == 0, "got wrong res[2] value %d\n", dlldata->res[2]);
    }
 
    ok_(__FILE__, line)(data.lpSectionGlobalData == NULL, "data.lpSectionGlobalData != NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == 0, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n",
       data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == NULL, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionStringW(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
                                    ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    libname, &data);
    ok_(__FILE__, line)(ret, "FindActCtxSectionStringW failed: %u\n", GetLastError());
    if (!ret) return;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(data.ulLength == 20, "data.ulLength=%u\n", data.ulLength);
    ok_(__FILE__, line)(data.lpSectionGlobalData == NULL, "data.lpSectionGlobalData != NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == 0, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n",
       data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == handle, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
 
    pReleaseActCtx(handle);
}

Referenced by test_actctx().

test_find_ifaceps_redirection()

static void test_find_ifaceps_redirection ( HANDLE  handle, const GUID *  iid, const GUID *  tlbid, const GUID *  base, const GUID *  ps32, ULONG  exid, int  line  )

static

Definition at line 1572 of file actctx.c.

{
    struct ifacepsredirect_data *ifaceps;
    ACTCTX_SECTION_KEYED_DATA data;
    BOOL ret;
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionGuid(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION,
                                    iid, &data);
    ok_(__FILE__, line)(ret, "FindActCtxSectionGuid failed: %u\n", GetLastError());
 
    ifaceps = (struct ifacepsredirect_data*)data.lpData;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(ifaceps->size == sizeof(*ifaceps), "got %d for header size\n", ifaceps->size);
    if (data.lpData && ifaceps->size == sizeof(*ifaceps))
    {
        ULONG len;
 
        /* for external proxy stubs it contains a value from 'proxyStubClsid32' */
        if (ps32)
        {
            ok_(__FILE__, line)(IsEqualGUID(&ifaceps->iid, ps32), "got wrong iid %s\n", wine_dbgstr_guid(&ifaceps->iid));
        }
        else
            ok_(__FILE__, line)(IsEqualGUID(&ifaceps->iid, iid), "got wrong iid %s\n", wine_dbgstr_guid(&ifaceps->iid));
 
        ok_(__FILE__, line)(IsEqualGUID(&ifaceps->tlbid, tlbid), "got wrong tlid %s\n", wine_dbgstr_guid(&ifaceps->tlbid));
        ok_(__FILE__, line)(ifaceps->name_len > 0, "got modulename len %d\n", ifaceps->name_len);
        ok_(__FILE__, line)(ifaceps->name_offset == ifaceps->size, "got progid offset %d\n", ifaceps->name_offset);
 
        /* data length is simply header length + string data length including nulls */
        len = ifaceps->size + ifaceps->name_len + sizeof(WCHAR);
        ok_(__FILE__, line)(data.ulLength == len, "got wrong data length %d, expected %d\n", data.ulLength, len);
 
        /* mask purpose is to indicate if attribute was specified, for testing purposes assume that manifest
           always has non-zero value for it */
        if (ifaceps->mask & NumMethods)
            ok_(__FILE__, line)(ifaceps->nummethods != 0, "got nummethods %d\n", ifaceps->nummethods);
        if (ifaceps->mask & BaseIface)
            ok_(__FILE__, line)(IsEqualGUID(&ifaceps->base, base), "got base %s\n", wine_dbgstr_guid(&ifaceps->base));
    }
 
    ok_(__FILE__, line)(data.lpSectionGlobalData == NULL, "data.lpSectionGlobalData != NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == 0, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n",
       data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == NULL, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
}

Referenced by test_actctx().

test_find_progid_redirection()

static void test_find_progid_redirection ( HANDLE  handle, const GUID *  clsid, const char *  progid, ULONG  exid, int  line  )

static

Definition at line 1704 of file actctx.c.

{
    struct progidredirect_data *progiddata;
    struct comclassredirect_data *comclass;
    ACTCTX_SECTION_KEYED_DATA data, data2;
    struct strsection_header *header;
    BOOL ret;
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionStringA(0, NULL,
                                       ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION,
                                       progid, &data);
    ok_(__FILE__, line)(ret, "FindActCtxSectionStringA failed: %u\n", GetLastError());
 
    progiddata = (struct progidredirect_data*)data.lpData;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(progiddata->size == sizeof(*progiddata), "got %d for header size\n", progiddata->size);
    if (data.lpData && progiddata->size == sizeof(*progiddata))
    {
        GUID *guid;
 
        ok_(__FILE__, line)(progiddata->reserved == 0, "got reserved as %d\n", progiddata->reserved);
        ok_(__FILE__, line)(progiddata->clsid_offset > 0, "got clsid_offset as %d\n", progiddata->clsid_offset);
 
        /* progid data points to generated alias guid */
        guid = (GUID*)((BYTE*)data.lpSectionBase + progiddata->clsid_offset);
 
        memset(&data2, 0, sizeof(data2));
        data2.cbSize = sizeof(data2);
        ret = pFindActCtxSectionGuid(0, NULL,
                                        ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                                        guid, &data2);
        ok_(__FILE__, line)(ret, "FindActCtxSectionGuid failed: %u\n", GetLastError());
 
        comclass = (struct comclassredirect_data*)data2.lpData;
        ok_(__FILE__, line)(IsEqualGUID(guid, &comclass->alias), "got wrong alias referenced from progid %s, %s\n", progid, wine_dbgstr_guid(guid));
        ok_(__FILE__, line)(IsEqualGUID(clsid, &comclass->clsid), "got wrong class referenced from progid %s, %s\n", progid, wine_dbgstr_guid(clsid));
    }
 
    header = (struct strsection_header*)data.lpSectionBase;
    ok_(__FILE__, line)(data.lpSectionGlobalData == (BYTE*)header + header->global_offset, "data.lpSectionGlobalData == NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == header->global_len, "data.ulSectionGlobalDataLength=%u\n", data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n", data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == NULL, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
        data.ulAssemblyRosterIndex, exid);
}

Referenced by test_actctx().

test_find_string_fail()

static void test_find_string_fail ( void  )

static

Definition at line 1289 of file actctx.c.

{
    ACTCTX_SECTION_KEYED_DATA data = {sizeof(data)};
    BOOL ret;
 
    ret = pFindActCtxSectionStringW(0, NULL, 100, testlib_dll, &data);
    ok(!ret, "FindActCtxSectionStringW succeeded\n");
    ok(GetLastError() == ERROR_SXS_SECTION_NOT_FOUND, "GetLastError()=%u\n", GetLastError());
 
    ret = pFindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    testlib2_dll, &data);
    ok(!ret, "FindActCtxSectionStringW succeeded\n");
    ok(GetLastError() == ERROR_SXS_KEY_NOT_FOUND, "GetLastError()=%u\n", GetLastError());
 
    ret = pFindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    testlib_dll, NULL);
    ok(!ret, "FindActCtxSectionStringW succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError()=%u\n", GetLastError());
 
    ret = pFindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    NULL, &data);
    ok(!ret, "FindActCtxSectionStringW succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError()=%u\n", GetLastError());
 
    data.cbSize = 0;
    ret = pFindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    testlib_dll, &data);
    ok(!ret, "FindActCtxSectionStringW succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError()=%u\n", GetLastError());
 
    data.cbSize = 35;
    ret = pFindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
                                    testlib_dll, &data);
    ok(!ret, "FindActCtxSectionStringW succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError()=%u\n", GetLastError());
}

Referenced by test_actctx().

test_find_surrogate()

static void test_find_surrogate ( HANDLE  handle, const GUID *  clsid, const WCHAR *  name, const WCHAR *  version, ULONG  exid, int  line  )

static

Definition at line 1643 of file actctx.c.

{
    struct clrsurrogate_data *surrogate;
    ACTCTX_SECTION_KEYED_DATA data;
    BOOL ret;
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionGuid(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES,
                                    clsid, &data);
    if (!ret)
    {
        skip("surrogate sections are not supported\n");
        return;
    }
    ok_(__FILE__, line)(ret, "FindActCtxSectionGuid failed: %u\n", GetLastError());
 
    surrogate = (struct clrsurrogate_data*)data.lpData;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(surrogate->size == sizeof(*surrogate), "got %d for header size\n", surrogate->size);
    if (data.lpData && surrogate->size == sizeof(*surrogate))
    {
        WCHAR *ptrW;
        ULONG len;
 
        ok_(__FILE__, line)(surrogate->res == 0, "invalid res value %d\n", surrogate->res);
        ok_(__FILE__, line)(IsEqualGUID(&surrogate->clsid, clsid), "got wrong clsid %s\n", wine_dbgstr_guid(&surrogate->clsid));
 
        ok_(__FILE__, line)(surrogate->version_len == lstrlenW(version)*sizeof(WCHAR), "got version len %d\n", surrogate->version_len);
        ok_(__FILE__, line)(surrogate->version_offset == surrogate->size, "got version offset %d\n", surrogate->version_offset);
 
        ok_(__FILE__, line)(surrogate->name_len == lstrlenW(name)*sizeof(WCHAR), "got name len %d\n", surrogate->name_len);
        ok_(__FILE__, line)(surrogate->name_offset > surrogate->version_offset, "got name offset %d\n", surrogate->name_offset);
 
        len = surrogate->size + surrogate->name_len + surrogate->version_len + 2*sizeof(WCHAR);
        ok_(__FILE__, line)(data.ulLength == len, "got wrong data length %d, expected %d\n", data.ulLength, len);
 
        ptrW = (WCHAR*)((BYTE*)surrogate + surrogate->name_offset);
        ok(!lstrcmpW(ptrW, name), "got wrong name %s\n", wine_dbgstr_w(ptrW));
 
        ptrW = (WCHAR*)((BYTE*)surrogate + surrogate->version_offset);
        ok(!lstrcmpW(ptrW, version), "got wrong name %s\n", wine_dbgstr_w(ptrW));
    }
 
    ok_(__FILE__, line)(data.lpSectionGlobalData == NULL, "data.lpSectionGlobalData != NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == 0, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n",
       data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == NULL, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
}

Referenced by test_actctx().

test_find_window_class()

static void test_find_window_class ( HANDLE  handle, LPCWSTR  clsname, ULONG  exid, int  line  )

static

Definition at line 1192 of file actctx.c.

{
    struct wndclass_redirect_data *wnddata;
    struct strsection_header *header;
    ACTCTX_SECTION_KEYED_DATA data;
    BOOL ret;
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionStringW(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
                                    clsname, &data);
    ok_(__FILE__, line)(ret, "FindActCtxSectionStringW failed: %u, class %s\n", GetLastError(),
        wine_dbgstr_w(clsname));
    if (!ret) return;
 
    header = (struct strsection_header*)data.lpSectionBase;
    wnddata = (struct wndclass_redirect_data*)data.lpData;
 
    ok_(__FILE__, line)(header->magic == 0x64487353, "got wrong magic 0x%08x\n", header->magic);
    ok_(__FILE__, line)(header->count > 0, "got count %d\n", header->count);
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(wnddata->size == sizeof(*wnddata), "got %d for header size\n", wnddata->size);
    if (data.lpData && wnddata->size == sizeof(*wnddata))
    {
        static const WCHAR verW[] = {'6','.','5','.','4','.','3','!',0};
        WCHAR buff[50];
        WCHAR *ptr;
        ULONG len;
 
        ok_(__FILE__, line)(wnddata->res == 0, "got reserved as %d\n", wnddata->res);
        /* redirect class name (versioned or not) is stored just after header data */
        ok_(__FILE__, line)(wnddata->name_offset == wnddata->size, "got name offset as %d\n", wnddata->name_offset);
        ok_(__FILE__, line)(wnddata->module_len > 0, "got module name length as %d\n", wnddata->module_len);
 
        /* expected versioned name */
        lstrcpyW(buff, verW);
        lstrcatW(buff, clsname);
        ptr = (WCHAR*)((BYTE*)wnddata + wnddata->name_offset);
        ok_(__FILE__, line)(!lstrcmpW(ptr, buff), "got wrong class name %s, expected %s\n", wine_dbgstr_w(ptr), wine_dbgstr_w(buff));
        ok_(__FILE__, line)(lstrlenW(ptr)*sizeof(WCHAR) == wnddata->name_len,
            "got wrong class name length %d, expected %d\n", wnddata->name_len, lstrlenW(ptr));
 
        /* data length is simply header length + string data length including nulls */
        len = wnddata->size + wnddata->name_len + wnddata->module_len + 2*sizeof(WCHAR);
        ok_(__FILE__, line)(data.ulLength == len, "got wrong data length %d, expected %d\n", data.ulLength, len);
 
        if (data.ulSectionTotalLength > wnddata->module_offset)
        {
            WCHAR *modulename, *sectionptr;
 
            /* just compare pointers */
            modulename = (WCHAR*)((BYTE*)wnddata + wnddata->size + wnddata->name_len + sizeof(WCHAR));
            sectionptr = (WCHAR*)((BYTE*)data.lpSectionBase + wnddata->module_offset);
            ok_(__FILE__, line)(modulename == sectionptr, "got wrong name offset %p, expected %p\n", sectionptr, modulename);
        }
    }
 
    ok_(__FILE__, line)(data.lpSectionGlobalData == NULL, "data.lpSectionGlobalData != NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == 0, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n",
       data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == NULL, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
 
    memset(&data, 0xfe, sizeof(data));
    data.cbSize = sizeof(data);
 
    ret = pFindActCtxSectionStringW(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
                                    ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
                                    clsname, &data);
    ok_(__FILE__, line)(ret, "FindActCtxSectionStringW failed: %u, class %s\n", GetLastError(),
        wine_dbgstr_w(clsname));
    if (!ret) return;
 
    ok_(__FILE__, line)(data.cbSize == sizeof(data), "data.cbSize=%u\n", data.cbSize);
    ok_(__FILE__, line)(data.ulDataFormatVersion == 1, "data.ulDataFormatVersion=%u\n", data.ulDataFormatVersion);
    ok_(__FILE__, line)(data.lpData != NULL, "data.lpData == NULL\n");
    ok_(__FILE__, line)(data.ulLength > 0, "data.ulLength=%u\n", data.ulLength);
    ok_(__FILE__, line)(data.lpSectionGlobalData == NULL, "data.lpSectionGlobalData != NULL\n");
    ok_(__FILE__, line)(data.ulSectionGlobalDataLength == 0, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
    ok_(__FILE__, line)(data.lpSectionBase != NULL, "data.lpSectionBase == NULL\n");
    ok_(__FILE__, line)(data.ulSectionTotalLength > 0, "data.ulSectionTotalLength=%u\n", data.ulSectionTotalLength);
    ok_(__FILE__, line)(data.hActCtx == handle, "data.hActCtx=%p\n", data.hActCtx);
    ok_(__FILE__, line)(data.ulAssemblyRosterIndex == exid, "data.ulAssemblyRosterIndex=%u, expected %u\n",
       data.ulAssemblyRosterIndex, exid);
 
    pReleaseActCtx(handle);
}

Referenced by test_actctx().

test_findsectionstring()

static void test_findsectionstring ( void  )

static

Definition at line 2405 of file actctx.c.

{
    HANDLE handle;
    BOOL ret;
    ULONG_PTR cookie;
 
    handle = create_manifest("test.manifest", testdep_manifest3, __LINE__);
    ret = pActivateActCtx(handle, &cookie);
    ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
 
    /* first we show the parameter validation from kernel32 */
    kernel32_find(ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, "testdep", FALSE, __LINE__);
    kernel32_find(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "testlib.dll", TRUE, __LINE__);
    kernel32_find(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "testlib2.dll", TRUE, __LINE__);
    kernel32_find(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "testlib3.dll", FALSE, __LINE__);
    kernel32_find(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "wndClass", TRUE, __LINE__);
    kernel32_find(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "wndClass2", TRUE, __LINE__);
    kernel32_find(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "wndClass3", FALSE, __LINE__);
 
    /* then we show that ntdll plays by different rules */
    ntdll_find(ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, "testdep", FALSE, __LINE__);
    ntdll_find(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "testlib.dll", TRUE, __LINE__);
    ntdll_find(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "testlib2.dll", TRUE, __LINE__);
    ntdll_find(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "testlib3.dll", FALSE, __LINE__);
    ntdll_find(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "wndClass", TRUE, __LINE__);
    ntdll_find(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "wndClass2", TRUE, __LINE__);
    ntdll_find(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "wndClass3", FALSE, __LINE__);
 
    ret = pDeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
    pReleaseActCtx(handle);
}

Referenced by START_TEST().

test_info_in_assembly()

static void test_info_in_assembly ( HANDLE  handle, DWORD  id, const info_in_assembly *  exinfo, int  line  )

static

Definition at line 716 of file actctx.c.

{
    ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *info, info_tmp;
    SIZE_T size, exsize;
    ULONG len;
    BOOL b;
 
    exsize = sizeof(ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION);
    if (exinfo->manifest_path) exsize += (lstrlenW(exinfo->manifest_path)+1) * sizeof(WCHAR);
    if (exinfo->encoded_assembly_id) exsize += (strlen_aw(exinfo->encoded_assembly_id) + 1) * sizeof(WCHAR);
 
    size = 0xdeadbeef;
    b = pQueryActCtxW(0, handle, &id,
                      AssemblyDetailedInformationInActivationContext, &info_tmp,
                      sizeof(info_tmp), &size);
    ok_(__FILE__, line)(!b, "QueryActCtx succeeded\n");
    ok_(__FILE__, line)(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetLastError() = %u\n", GetLastError());
 
    ok_(__FILE__, line)(size >= exsize, "size=%lu, expected %lu\n", size, exsize);
 
    if (size == 0xdeadbeef)
    {
        skip("bad size\n");
        return;
    }
 
    info = HeapAlloc(GetProcessHeap(), 0, size);
    memset(info, 0xfe, size);
 
    size = 0xdeadbeef;
    b = pQueryActCtxW(0, handle, &id,
                      AssemblyDetailedInformationInActivationContext, info, size, &size);
    ok_(__FILE__, line)(b, "QueryActCtx failed: %u\n", GetLastError());
    if (!exinfo->manifest_path)
        exsize += info->ulManifestPathLength + sizeof(WCHAR);
    if (!exinfo->encoded_assembly_id)
        exsize += info->ulEncodedAssemblyIdentityLength + sizeof(WCHAR);
    if (exinfo->has_assembly_dir)
        exsize += info->ulAssemblyDirectoryNameLength + sizeof(WCHAR);
    ok_(__FILE__, line)(size == exsize, "size=%lu, expected %lu\n", size, exsize);
 
    if (0)  /* FIXME: flags meaning unknown */
    {
        ok_(__FILE__, line)((info->ulFlags) == exinfo->flags, "info->ulFlags = %x, expected %x\n",
           info->ulFlags, exinfo->flags);
    }
    if(exinfo->encoded_assembly_id) {
        len = strlen_aw(exinfo->encoded_assembly_id)*sizeof(WCHAR);
        ok_(__FILE__, line)(info->ulEncodedAssemblyIdentityLength == len,
           "info->ulEncodedAssemblyIdentityLength = %u, expected %u\n",
           info->ulEncodedAssemblyIdentityLength, len);
    } else {
        ok_(__FILE__, line)(info->ulEncodedAssemblyIdentityLength != 0,
           "info->ulEncodedAssemblyIdentityLength == 0\n");
    }
    ok_(__FILE__, line)(info->ulManifestPathType == ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE,
       "info->ulManifestPathType = %x\n", info->ulManifestPathType);
    if(exinfo->manifest_path) {
        len = lstrlenW(exinfo->manifest_path)*sizeof(WCHAR);
        ok_(__FILE__, line)(info->ulManifestPathLength == len, "info->ulManifestPathLength = %u, expected %u\n",
           info->ulManifestPathLength, len);
    } else {
        ok_(__FILE__, line)(info->ulManifestPathLength != 0, "info->ulManifestPathLength == 0\n");
    }
 
    ok_(__FILE__, line)(info->ulPolicyPathType == ACTIVATION_CONTEXT_PATH_TYPE_NONE,
       "info->ulPolicyPathType = %x\n", info->ulPolicyPathType);
    ok_(__FILE__, line)(info->ulPolicyPathLength == 0,
       "info->ulPolicyPathLength = %u, expected 0\n", info->ulPolicyPathLength);
    ok_(__FILE__, line)(info->ulMetadataSatelliteRosterIndex == 0, "info->ulMetadataSatelliteRosterIndex = %x\n",
       info->ulMetadataSatelliteRosterIndex);
    ok_(__FILE__, line)(info->ulManifestVersionMajor == 1,"info->ulManifestVersionMajor = %x\n",
       info->ulManifestVersionMajor);
    ok_(__FILE__, line)(info->ulManifestVersionMinor == 0, "info->ulManifestVersionMinor = %x\n",
       info->ulManifestVersionMinor);
    ok_(__FILE__, line)(info->ulPolicyVersionMajor == 0, "info->ulPolicyVersionMajor = %x\n",
       info->ulPolicyVersionMajor);
    ok_(__FILE__, line)(info->ulPolicyVersionMinor == 0, "info->ulPolicyVersionMinor = %x\n",
       info->ulPolicyVersionMinor);
    if(exinfo->has_assembly_dir)
        ok_(__FILE__, line)(info->ulAssemblyDirectoryNameLength != 0,
           "info->ulAssemblyDirectoryNameLength == 0\n");
    else
        ok_(__FILE__, line)(info->ulAssemblyDirectoryNameLength == 0,
           "info->ulAssemblyDirectoryNameLength != 0\n");
 
    ok_(__FILE__, line)(info->lpAssemblyEncodedAssemblyIdentity != NULL,
       "info->lpAssemblyEncodedAssemblyIdentity == NULL\n");
    if(info->lpAssemblyEncodedAssemblyIdentity && exinfo->encoded_assembly_id) {
        ok_(__FILE__, line)(!strcmp_aw(info->lpAssemblyEncodedAssemblyIdentity, exinfo->encoded_assembly_id),
           "unexpected info->lpAssemblyEncodedAssemblyIdentity %s / %s\n",
           strw(info->lpAssemblyEncodedAssemblyIdentity), exinfo->encoded_assembly_id);
    }
    if(exinfo->manifest_path) {
        ok_(__FILE__, line)(info->lpAssemblyManifestPath != NULL, "info->lpAssemblyManifestPath == NULL\n");
        if(info->lpAssemblyManifestPath)
            ok_(__FILE__, line)(!lstrcmpiW(info->lpAssemblyManifestPath, exinfo->manifest_path),
               "unexpected info->lpAssemblyManifestPath\n");
    }else {
        ok_(__FILE__, line)(info->lpAssemblyManifestPath != NULL, "info->lpAssemblyManifestPath == NULL\n");
    }
 
    ok_(__FILE__, line)(info->lpAssemblyPolicyPath == NULL, "info->lpAssemblyPolicyPath != NULL\n");
    if(info->lpAssemblyPolicyPath)
        ok_(__FILE__, line)(*(WORD*)info->lpAssemblyPolicyPath == 0, "info->lpAssemblyPolicyPath is not empty\n");
    if(exinfo->has_assembly_dir)
        ok_(__FILE__, line)(info->lpAssemblyDirectoryName != NULL, "info->lpAssemblyDirectoryName == NULL\n");
    else
        ok_(__FILE__, line)(info->lpAssemblyDirectoryName == NULL, "info->lpAssemblyDirectoryName = %s\n",
           strw(info->lpAssemblyDirectoryName));
    HeapFree(GetProcessHeap(), 0, info);
}

Referenced by test_actctx(), and test_app_manifest().

test_no_compat()

static void test_no_compat ( HANDLE  handle, int  line  )

static

Definition at line 2755 of file actctx.c.

{
    test_act_ctx_compat_info compat_info;
    SIZE_T size;
    BOOL b;
 
    memset(&compat_info, 0, sizeof(compat_info));
    b = pQueryActCtxW(QUERY_ACTCTX_FLAG_NO_ADDREF, handle, NULL,
                      CompatibilityInformationInActivationContext, &compat_info,
                      sizeof(compat_info), &size);
 
    ok_(__FILE__, line)(b, "CompatibilityInformationInActivationContext failed\n");
    ok_(__FILE__, line)(size == sizeof(DWORD), "size mismatch (got %lu, expected 4)\n", size);
    ok_(__FILE__, line)(compat_info.ElementCount == 0, "unexpected ElementCount %u\n", compat_info.ElementCount);
}

Referenced by test_compatibility().

test_runlevel_info()

static void test_runlevel_info ( HANDLE  handle, const runlevel_info_t *  exinfo, int  line  )

static

Definition at line 898 of file actctx.c.

{
    ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION runlevel_info;
    SIZE_T size, retsize;
    BOOL b;
 
    size = sizeof(runlevel_info);
    b = pQueryActCtxW(0, handle, NULL,
                      RunlevelInformationInActivationContext, &runlevel_info,
                      sizeof(runlevel_info), &retsize);
    if (!b && GetLastError() == ERROR_INVALID_PARAMETER)
    {
        win_skip("RunlevelInformationInActivationContext not supported.\n");
        return;
    }
 
    ok_(__FILE__, line)(b, "QueryActCtx failed: %u\n", GetLastError());
    ok_(__FILE__, line)(retsize == size, "size=%ld, expected %ld\n", retsize, size);
 
    ok_(__FILE__, line)(runlevel_info.ulFlags == 0, "runlevel_info.ulFlags=%x\n", runlevel_info.ulFlags);
    ok_(__FILE__, line)(runlevel_info.RunLevel == exinfo->run_level,
       "runlevel_info.RunLevel=%u, expected %u\n", runlevel_info.RunLevel, exinfo->run_level);
    ok_(__FILE__, line)(runlevel_info.UiAccess == exinfo->ui_access,
       "runlevel_info.UiAccess=%u, expected %u\n", runlevel_info.UiAccess, exinfo->ui_access);
}

Referenced by test_actctx().

test_typelib_section()

static void test_typelib_section ( void  )

static

Definition at line 1878 of file actctx.c.

{
    static const WCHAR helpW[] = {'h','e','l','p'};
    ACTCTX_SECTION_KEYED_DATA data, data2;
    struct guidsection_header *section;
    struct tlibredirect_data *tlib;
    ULONG_PTR cookie;
    HANDLE handle;
    BOOL ret;
 
    /* use two dependent manifests, 4 'files' total */
    create_manifest_file("testdep1.manifest", manifest_wndcls1, -1, NULL, NULL);
    create_manifest_file("testdep2.manifest", manifest_wndcls2, -1, NULL, NULL);
    create_manifest_file("main_wndcls.manifest", manifest_wndcls_main, -1, NULL, NULL);
 
    handle = test_create("main_wndcls.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
 
    DeleteFileA("testdep1.manifest");
    DeleteFileA("testdep2.manifest");
    DeleteFileA("main_wndcls.manifest");
 
    ret = pActivateActCtx(handle, &cookie);
    ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
 
    memset(&data, 0, sizeof(data));
    memset(&data2, 0, sizeof(data2));
    data.cbSize = sizeof(data);
    data2.cbSize = sizeof(data2);
 
    /* get data for two typelibs from different assemblies */
    ret = pFindActCtxSectionGuid(0, NULL,
                                 ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION,
                                 &IID_TlibTest, &data);
    ok(ret, "got %d\n", ret);
 
    ret = pFindActCtxSectionGuid(0, NULL,
                                 ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION,
                                 &IID_TlibTest4, &data2);
    ok(ret, "got %d\n", ret);
 
    section = (struct guidsection_header*)data.lpSectionBase;
    ok(section->count == 4, "got %d\n", section->count);
    ok(section->size == sizeof(*section), "got %d\n", section->size);
 
    /* For both GUIDs same section is returned */
    ok(data.lpSectionBase == data2.lpSectionBase, "got %p, %p\n", data.lpSectionBase, data2.lpSectionBase);
    ok(data.ulSectionTotalLength == data2.ulSectionTotalLength, "got %u, %u\n", data.ulSectionTotalLength,
        data2.ulSectionTotalLength);
 
    ok(data.lpSectionGlobalData == ((BYTE*)section + section->names_offset), "data.lpSectionGlobalData == NULL\n");
    ok(data.ulSectionGlobalDataLength == section->names_len, "data.ulSectionGlobalDataLength=%u\n",
       data.ulSectionGlobalDataLength);
 
    /* test some actual data */
    tlib = (struct tlibredirect_data*)data.lpData;
    ok(tlib->size == sizeof(*tlib), "got %d\n", tlib->size);
    ok(tlib->major_version == 1, "got %d\n", tlib->major_version);
    ok(tlib->minor_version == 0, "got %d\n", tlib->minor_version);
    ok(tlib->help_offset > 0, "got %d\n", tlib->help_offset);
    ok(tlib->help_len == sizeof(helpW), "got %d\n", tlib->help_len);
    ok(tlib->flags == (LIBFLAG_FHIDDEN|LIBFLAG_FCONTROL|LIBFLAG_FRESTRICTED), "got %x\n", tlib->flags);
 
    ret = pDeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
 
    pReleaseActCtx(handle);
}

Referenced by test_actctx().

test_with_compat()

static void test_with_compat ( HANDLE  handle, DWORD  num_compat, const GUID *  expected_compat[], int  line  )

static

Definition at line 2771 of file actctx.c.

{
    test_act_ctx_compat_info compat_info;
    SIZE_T size;
    SIZE_T expected = sizeof(COMPATIBILITY_CONTEXT_ELEMENT) * num_compat + sizeof(DWORD);
    DWORD n;
    BOOL b;
 
    memset(&compat_info, 0, sizeof(compat_info));
    b = pQueryActCtxW(QUERY_ACTCTX_FLAG_NO_ADDREF, handle, NULL,
                      CompatibilityInformationInActivationContext, &compat_info,
                      sizeof(compat_info), &size);
 
    ok_(__FILE__, line)(b, "CompatibilityInformationInActivationContext failed\n");
    ok_(__FILE__, line)(size == expected, "size mismatch (got %lu, expected %lu)\n", size, expected);
    ok_(__FILE__, line)(compat_info.ElementCount == num_compat, "unexpected ElementCount %u\n", compat_info.ElementCount);
 
    for (n = 0; n < num_compat; ++n)
    {
        ok_(__FILE__, line)(IsEqualGUID(&compat_info.Elements[n].Id, expected_compat[n]),
                            "got wrong clsid %s, expected %s for %u\n",
                            wine_dbgstr_guid(&compat_info.Elements[n].Id),
                            wine_dbgstr_guid(expected_compat[n]),
                            n);
        ok_(__FILE__, line)(compat_info.Elements[n].Type == ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS,
                            "Wrong type, got %u for %u\n", (DWORD)compat_info.Elements[n].Type, n);
    }
}

Referenced by test_compatibility().

test_wndclass_section()

static void test_wndclass_section ( void  )

static

Definition at line 1758 of file actctx.c.

{
    static const WCHAR cls1W[] = {'1','.','2','.','3','.','4','!','w','n','d','C','l','a','s','s','1',0};
    ACTCTX_SECTION_KEYED_DATA data, data2;
    struct wndclass_redirect_data *classdata;
    struct strsection_header *section;
    ULONG_PTR cookie;
    HANDLE handle;
    WCHAR *ptrW;
    BOOL ret;
 
    /* use two dependent manifests, each defines 2 window class redirects */
    create_manifest_file("testdep1.manifest", manifest_wndcls1, -1, NULL, NULL);
    create_manifest_file("testdep2.manifest", manifest_wndcls2, -1, NULL, NULL);
    create_manifest_file("main_wndcls.manifest", manifest_wndcls_main, -1, NULL, NULL);
 
    handle = test_create("main_wndcls.manifest");
    ok(handle != INVALID_HANDLE_VALUE, "handle == INVALID_HANDLE_VALUE, error %u\n", GetLastError());
 
    DeleteFileA("testdep1.manifest");
    DeleteFileA("testdep2.manifest");
    DeleteFileA("main_wndcls.manifest");
 
    ret = pActivateActCtx(handle, &cookie);
    ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
 
    memset(&data, 0, sizeof(data));
    memset(&data2, 0, sizeof(data2));
    data.cbSize = sizeof(data);
    data2.cbSize = sizeof(data2);
 
    /* get data for two classes from different assemblies */
    ret = pFindActCtxSectionStringW(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
                                    wndClass1W, &data);
    ok(ret, "got %d\n", ret);
    ret = pFindActCtxSectionStringW(0, NULL,
                                    ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
                                    wndClass3W, &data2);
    ok(ret, "got %d\n", ret);
 
    section = (struct strsection_header*)data.lpSectionBase;
    ok(section->count == 4, "got %d\n", section->count);
    ok(section->size == sizeof(*section), "got %d\n", section->size);
 
    /* For both string same section is returned, meaning it's one wndclass section per context */
    ok(data.lpSectionBase == data2.lpSectionBase, "got %p, %p\n", data.lpSectionBase, data2.lpSectionBase);
    ok(data.ulSectionTotalLength == data2.ulSectionTotalLength, "got %u, %u\n", data.ulSectionTotalLength,
        data2.ulSectionTotalLength);
 
    /* wndClass1 is versioned, wndClass3 is not */
    classdata = (struct wndclass_redirect_data*)data.lpData;
    ptrW = (WCHAR*)((BYTE*)data.lpData + classdata->name_offset);
    ok(!lstrcmpW(ptrW, cls1W), "got %s\n", wine_dbgstr_w(ptrW));
 
    classdata = (struct wndclass_redirect_data*)data2.lpData;
    ptrW = (WCHAR*)((BYTE*)data2.lpData + classdata->name_offset);
    ok(!lstrcmpW(ptrW, wndClass3W), "got %s\n", wine_dbgstr_w(ptrW));
 
    ret = pDeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
 
    pReleaseActCtx(handle);
}

Referenced by test_actctx().

test_ZombifyActCtx()

static void test_ZombifyActCtx ( void  )

static

Definition at line 2678 of file actctx.c.

{
    ACTIVATION_CONTEXT_BASIC_INFORMATION basicinfo;
    ULONG_PTR cookie;
    HANDLE handle, current;
    BOOL ret;
 
    SetLastError(0xdeadbeef);
    ret = pZombifyActCtx(NULL);
todo_wine
    ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
 
    handle = create_manifest("test.manifest", testdep_manifest3, __LINE__);
 
    ret = pGetCurrentActCtx(&current);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(current == NULL, "got %p\n", current);
 
    ret = pActivateActCtx(handle, &cookie);
    ok(ret, "ActivateActCtx failed: %u\n", GetLastError());
 
    ret = pGetCurrentActCtx(&current);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(handle == current, "got %p, %p\n", current, handle);
 
    memset(&basicinfo, 0xff, sizeof(basicinfo));
    ret = pQueryActCtxW(0, handle, 0, ActivationContextBasicInformation,
        &basicinfo, sizeof(basicinfo), NULL);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(basicinfo.hActCtx == handle, "got %p\n", basicinfo.hActCtx);
    ok(basicinfo.dwFlags == 0, "got %x\n", basicinfo.dwFlags);
 
    memset(&basicinfo, 0xff, sizeof(basicinfo));
    ret = pQueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, NULL, 0, ActivationContextBasicInformation,
        &basicinfo, sizeof(basicinfo), NULL);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(basicinfo.hActCtx == handle, "got %p\n", basicinfo.hActCtx);
    ok(basicinfo.dwFlags == 0, "got %x\n", basicinfo.dwFlags);
 
    ret = pZombifyActCtx(handle);
todo_wine
    ok(ret, "got %d\n", ret);
 
    memset(&basicinfo, 0xff, sizeof(basicinfo));
    ret = pQueryActCtxW(0, handle, 0, ActivationContextBasicInformation,
        &basicinfo, sizeof(basicinfo), NULL);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(basicinfo.hActCtx == handle, "got %p\n", basicinfo.hActCtx);
    ok(basicinfo.dwFlags == 0, "got %x\n", basicinfo.dwFlags);
 
    memset(&basicinfo, 0xff, sizeof(basicinfo));
    ret = pQueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, NULL, 0, ActivationContextBasicInformation,
        &basicinfo, sizeof(basicinfo), NULL);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(basicinfo.hActCtx == handle, "got %p\n", basicinfo.hActCtx);
    ok(basicinfo.dwFlags == 0, "got %x\n", basicinfo.dwFlags);
 
    ret = pGetCurrentActCtx(&current);
    ok(ret, "got %d, error %d\n", ret, GetLastError());
    ok(current == handle, "got %p\n", current);
 
    /* one more time */
    ret = pZombifyActCtx(handle);
todo_wine
    ok(ret, "got %d\n", ret);
 
    ret = pDeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx failed: %u\n", GetLastError());
    pReleaseActCtx(handle);
}

Referenced by START_TEST().

VOID() [1/2]

static VOID ( NTAPI *  pRtlFreeUnicodeString )

static

VOID() [2/2]

static SIZE_T *static VOID ( WINAPI *  pReleaseActCtx )

static

write_manifest()

static void write_manifest ( const char *  filename, const char *  manifest  )

static

Definition at line 2500 of file actctx.c.

{
    HANDLE file;
    DWORD size;
    CHAR path[MAX_PATH];
 
    GetTempPathA(sizeof(path)/sizeof(CHAR), path);
    strcat(path, filename);
 
    file = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %u\n", GetLastError());
    WriteFile(file, manifest, strlen(manifest), &size, NULL);
    CloseHandle(file);
}

Referenced by test_CreateActCtx().

Variable Documentation

app_dir

WCHAR app_dir[MAX_PATH]

static

Definition at line 469 of file actctx.c.

Referenced by init_paths().

app_manifest_path

WCHAR app_manifest_path[MAX_PATH]

static

Definition at line 470 of file actctx.c.

Referenced by init_paths().

compat_manifest_no_supportedOs

const char compat_manifest_no_supportedOs[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"   <assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"   <compatibility xmlns=\"urn:schemas-microsoft-com:compatibility.v1\">"
"       <application>"
"       </application>"
"   </compatibility>"
"</assembly>"

Definition at line 405 of file actctx.c.

Referenced by test_compatibility().

compat_manifest_other_guid

const char compat_manifest_other_guid[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"   <assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"   <compatibility xmlns=\"urn:schemas-microsoft-com:compatibility.v1\">"
"       <application>"
"           <supportedOS Id=\"{12345566-1111-2222-3333-444444444444}\" />"
"       </application>"
"   </compatibility>"
"</assembly>"

Definition at line 438 of file actctx.c.

Referenced by test_compatibility().

compat_manifest_vista

const char compat_manifest_vista[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"   <assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"   <compatibility xmlns=\"urn:schemas-microsoft-com:compatibility.v1\">"
"       <application>"
"           <supportedOS Id=\"{e2011457-1546-43c5-a5fe-008deee3d3f0}\" />"  
"       </application>"
"   </compatibility>"
"</assembly>"

Definition at line 414 of file actctx.c.

Referenced by test_compatibility().

compat_manifest_vista_7_8_10_81

const char compat_manifest_vista_7_8_10_81[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"   <assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"   <compatibility xmlns=\"urn:schemas-microsoft-com:compatibility.v1\">"
"       <application>"
"           <supportedOS Id=\"{e2011457-1546-43c5-a5fe-008deee3d3f0}\" ></supportedOS>"  
"           <supportedOS Id=\"{35138b9a-5d96-4fbd-8e2d-a2440225f93a}\" />"  
"           <supportedOS Id=\"{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}\" ></supportedOS>"  
"           <supportedOS Id=\"{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}\" />"  
"           <supportedOS Id=\"{1f676c76-80e1-4239-95bb-83d0f6d0da78}\" />"  
"       </application>"
"   </compatibility>"
"</assembly>"

Definition at line 424 of file actctx.c.

Referenced by test_compatibility().

depmanifest1_info

const info_in_assembly depmanifest1_info

static

Initial value:

= {
    0x10, depmanifest_path,
    "testdep,processorArchitecture=\"" ARCH "\","
    "type=\"win32\",version=\"6.5.4.3\"",
    TRUE
}

Definition at line 692 of file actctx.c.

Referenced by test_actctx().

depmanifest2_info

const info_in_assembly depmanifest2_info

static

Initial value:

= {
    0x10, depmanifest_path,
    "testdep,processorArchitecture=\"" ARCH "\","
    "type=\"win32\",version=\"6.5.4.3\"",
    TRUE
}

Definition at line 699 of file actctx.c.

Referenced by test_actctx().

depmanifest3_info

const info_in_assembly depmanifest3_info

static

Initial value:

= {
    0x10, depmanifest_path,
    "testdep,processorArchitecture=\"" ARCH "\",type=\"win32\",version=\"6.5.4.3\"",
    TRUE
}

Definition at line 706 of file actctx.c.

Referenced by test_actctx().

depmanifest_path

WCHAR depmanifest_path[MAX_PATH]

static

Definition at line 470 of file actctx.c.

Referenced by create_manifest_file().

detailed_info0

const detailed_info_t detailed_info0

static

Initial value:

= {
    0, 0, 0, 0, NULL, 0, 0, NULL
}

Definition at line 552 of file actctx.c.

Referenced by test_actctx().

detailed_info1

const detailed_info_t detailed_info1

static

Initial value:

= {
    1, 1, 1, ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE, manifest_path,
    ACTIVATION_CONTEXT_PATH_TYPE_NONE, ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE,
    work_dir,
}

Definition at line 556 of file actctx.c.

Referenced by test_actctx().

detailed_info1_child

const detailed_info_t detailed_info1_child

static

Initial value:

= {
    1, 1, 1, ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE, app_manifest_path,
    ACTIVATION_CONTEXT_PATH_TYPE_NONE, ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE,
    app_dir,
}

Definition at line 562 of file actctx.c.

Referenced by test_app_manifest().

detailed_info2

const detailed_info_t detailed_info2

static

Initial value:

= {
    1, 2, 3, ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE, manifest_path,
    ACTIVATION_CONTEXT_PATH_TYPE_NONE, ACTIVATION_CONTEXT_PATH_TYPE_WIN32_FILE,
    work_dir,
}

Definition at line 569 of file actctx.c.

Referenced by test_actctx().

exe_path

WCHAR exe_path[MAX_PATH]

static

Definition at line 469 of file actctx.c.

Referenced by init_paths().

HANDLE

HANDLE

Definition at line 40 of file actctx.c.

LPCSTR

const GUID LPCSTR

Definition at line 36 of file actctx.c.

LPCWSTR

const GUID LPCWSTR

Definition at line 37 of file actctx.c.

manifest1

const char manifest1[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"</assembly>"

Definition at line 71 of file actctx.c.

Referenced by run_child_process(), test_actctx(), test_compatibility(), test_create_fail(), and test_CreateActCtx().

manifest1_1

const char manifest1_1[]

static

Initial value:

=
"<assembly xmlns = \"urn:schemas-microsoft-com:asm.v1\" manifestVersion = \"1.0\">"
"<assemblyIdentity version = \"1.0.0.0\" name = \"Wine.Test\" type = \"win32\"></assemblyIdentity>"
"</assembly>"

Definition at line 76 of file actctx.c.

Referenced by test_actctx().

manifest1_child_info

const info_in_assembly manifest1_child_info

static

Initial value:

= {
    1, app_manifest_path,
    "Wine.Test,type=\"win32\",version=\"1.0.0.0\"",
    FALSE
}

Definition at line 668 of file actctx.c.

Referenced by test_app_manifest().

manifest1_info

const info_in_assembly manifest1_info

static

Initial value:

= {
    1, manifest_path,
    "Wine.Test,type=\"win32\",version=\"1.0.0.0\"",
    FALSE
}

Definition at line 662 of file actctx.c.

Referenced by test_actctx().

manifest2

const char manifest2[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\">"
"</assemblyIdentity>"
"<dependency>"
"<dependentAssembly>"
"<assemblyIdentity type=\"win32\" name=\"testdep\" version=\"6.5.4.3\" processorArchitecture=\"" ARCH "\">"
"</assemblyIdentity>"
"</dependentAssembly>"
"</dependency>"
"</assembly>"

Definition at line 81 of file actctx.c.

Referenced by test_actctx(), and test_create_fail().

manifest2_info

const info_in_assembly manifest2_info

static

Initial value:

= {
    1, manifest_path,
    "Wine.Test,type=\"win32\",version=\"1.2.3.4\"",
    FALSE
}

Definition at line 674 of file actctx.c.

Referenced by test_actctx().

manifest3

const char manifest3[]

static

Definition at line 107 of file actctx.c.

Referenced by test_actctx().

manifest3_info

const info_in_assembly manifest3_info

static

Initial value:

= {
    1, manifest_path,
    "Wine.Test,publicKeyToken=\"6595b6414666f1df\",type=\"win32\",version=\"1.2.3.4\"",
    FALSE
}

Definition at line 680 of file actctx.c.

Referenced by test_actctx().

manifest4

const char manifest4[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\">"
"</assemblyIdentity>"
"<dependency>"
"<dependentAssembly>"
"<assemblyIdentity type=\"win32\" name=\"Microsoft.Windows.Common-Controls\" "
    "version=\"6.0.1.0\" processorArchitecture=\"" ARCH "\" publicKeyToken=\"6595b64144ccf1df\">"
"</assemblyIdentity>"
"</dependentAssembly>"
"</dependency>"
"</assembly>"

Definition at line 223 of file actctx.c.

Referenced by test_actctx().

manifest4_info

const info_in_assembly manifest4_info

static

Initial value:

= {
    1, manifest_path,
    "Wine.Test,type=\"win32\",version=\"1.2.3.4\"",
    FALSE
}

Definition at line 686 of file actctx.c.

Referenced by test_actctx().

manifest5

const char manifest5[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\">"
"</assemblyIdentity>"
"<dependency>"
"    <dependentAssembly dependencyType=\"preRequisite\" allowDelayedBinding=\"true\">"
"        <assemblyIdentity name=\"Missing.Assembly\" version=\"1.0.0.0\" />"
"    </dependentAssembly>"
"</dependency>"
"</assembly>"

Definition at line 236 of file actctx.c.

Referenced by test_allowDelayedBinding().

manifest6

const char manifest6[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v1\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel level=\"ASINVOKER\" uiAccess=\"false\"/>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"</assembly>"

Definition at line 247 of file actctx.c.

Referenced by test_actctx().

manifest7

const char manifest7[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel level=\"requireAdministrator\" uiAccess=\"TRUE\"/>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"</assembly>"

Definition at line 259 of file actctx.c.

Referenced by test_actctx().

manifest8

const char manifest8[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel level=\"requireAdministrator\" uiAccess=\"true\">"
"            </requestedExecutionLevel>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"</assembly>"

Definition at line 271 of file actctx.c.

Referenced by test_actctx().

manifest9

const char manifest9[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel level=\"requireAdministrator\"/>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"</assembly>"

Definition at line 284 of file actctx.c.

Referenced by test_actctx().

manifest_comctrl_info

const info_in_assembly manifest_comctrl_info

static

Initial value:

= {
    0, NULL, NULL, TRUE 
}

Definition at line 712 of file actctx.c.

Referenced by test_actctx().

manifest_path

WCHAR manifest_path[MAX_PATH]

static

Definition at line 470 of file actctx.c.

Referenced by create_manifest_file(), and test_create().

manifest_wndcls1

const char manifest_wndcls1[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.2.3.4\"  name=\"testdep1\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
"<file name=\"testlib1.dll\">"
"<windowClass versioned=\"yes\">wndClass1</windowClass>"
"<windowClass>wndClass2</windowClass>"
" <typelib tlbid=\"{99999999-8888-7777-6666-555555555558}\" version=\"1.0\" helpdir=\"\" />"
"</file>"
"<file name=\"testlib1_2.dll\" />"
"</assembly>"

Definition at line 183 of file actctx.c.

Referenced by test_CreateActCtx(), test_dllredirect_section(), test_typelib_section(), and test_wndclass_section().

manifest_wndcls2

const char manifest_wndcls2[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"4.3.2.1\"  name=\"testdep2\" type=\"win32\" processorArchitecture=\"" ARCH "\" />"
"<file name=\"testlib2.dll\">"
" <windowClass versioned=\"no\">wndClass3</windowClass>"
" <windowClass>wndClass4</windowClass>"
" <typelib tlbid=\"{99999999-8888-7777-6666-555555555555}\" version=\"1.0\" helpdir=\"help\" resourceid=\"409\""
"          flags=\"HiddeN,CoNTROL,rESTRICTED\" />"
" <typelib tlbid=\"{99999999-8888-7777-6666-555555555556}\" version=\"1.0\" helpdir=\"help1\" resourceid=\"409\" />"
" <typelib tlbid=\"{99999999-8888-7777-6666-555555555557}\" version=\"1.0\" helpdir=\"\" />"
"</file>"
"<file name=\"testlib2_2.dll\" />"
"</assembly>"

Definition at line 194 of file actctx.c.

Referenced by test_CreateActCtx(), test_dllredirect_section(), test_typelib_section(), and test_wndclass_section().

manifest_wndcls_main

const char manifest_wndcls_main[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
"<dependency>"
" <dependentAssembly>"
"  <assemblyIdentity type=\"win32\" name=\"testdep1\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
" </dependentAssembly>"
"</dependency>"
"<dependency>"
" <dependentAssembly>"
"  <assemblyIdentity type=\"win32\" name=\"testdep2\" version=\"4.3.2.1\" processorArchitecture=\"" ARCH "\" />"
" </dependentAssembly>"
"</dependency>"
"</assembly>"

Definition at line 208 of file actctx.c.

Referenced by test_CreateActCtx(), test_dllredirect_section(), test_typelib_section(), and test_wndclass_section().

PACTCTX_SECTION_KEYED_DATA

static const GUID PACTCTX_SECTION_KEYED_DATA

Definition at line 36 of file actctx.c.

Referenced by RtlFindActivationContextSectionString(), and test_pack_PACTCTX_SECTION_KEYED_DATA().

PCSZ

PCSZ

Definition at line 46 of file actctx.c.

PUNICODE_STRING

const GUID PUNICODE_STRING

Definition at line 45 of file actctx.c.

PVOID

PVOID

Definition at line 40 of file actctx.c.

Referenced by RtlActivateActivationContextUnsafeFast(), and RtlCreateActivationContext().

runlevel_info0

const runlevel_info_t runlevel_info0

static

Initial value:

= {
    ACTCTX_RUN_LEVEL_UNSPECIFIED, FALSE,
}

Definition at line 878 of file actctx.c.

Referenced by test_actctx().

runlevel_info6

const runlevel_info_t runlevel_info6

static

Initial value:

= {
    ACTCTX_RUN_LEVEL_AS_INVOKER, FALSE,
}

Definition at line 882 of file actctx.c.

Referenced by test_actctx().

runlevel_info7

const runlevel_info_t runlevel_info7

static

Initial value:

= {
    ACTCTX_RUN_LEVEL_REQUIRE_ADMIN, TRUE,
}

Definition at line 886 of file actctx.c.

Referenced by test_actctx().

runlevel_info8

const runlevel_info_t runlevel_info8

static

Initial value:

= {
    ACTCTX_RUN_LEVEL_REQUIRE_ADMIN, TRUE,
}

Definition at line 890 of file actctx.c.

Referenced by test_actctx().

runlevel_info9

const runlevel_info_t runlevel_info9

static

Initial value:

= {
    ACTCTX_RUN_LEVEL_REQUIRE_ADMIN, FALSE,
}

Definition at line 894 of file actctx.c.

Referenced by test_actctx().

SIZE_T

SIZE_T

Definition at line 40 of file actctx.c.

testdep_manifest1

const char testdep_manifest1[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity type=\"win32\" name=\"testdep\" version=\"6.5.4.3\" processorArchitecture=\"" ARCH "\"/>"
"</assembly>"

Definition at line 302 of file actctx.c.

Referenced by test_actctx().

testdep_manifest2

const char testdep_manifest2[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity type=\"win32\" name=\"testdep\" version=\"6.5.4.3\" processorArchitecture=\"" ARCH "\" />"
"<file name=\"testlib.dll\"></file>"
"<file name=\"testlib2.dll\" hash=\"63c978c2b53d6cf72b42fb7308f9af12ab19ec53\" hashalg=\"SHA1\" />"
"</assembly>"

Definition at line 307 of file actctx.c.

Referenced by test_actctx().

testdep_manifest3

const char testdep_manifest3[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\"> "
"<assemblyIdentity type=\"win32\" name=\"testdep\" version=\"6.5.4.3\" processorArchitecture=\"" ARCH "\"/>"
"<file name=\"testlib.dll\"/>"
"<file name=\"testlib2.dll\" hash=\"63c978c2b53d6cf72b42fb7308f9af12ab19ec53\" hashalg=\"SHA1\">"
"<windowClass>wndClass</windowClass>"
"<windowClass>wndClass2</windowClass>"
"</file>"
"</assembly>"

Definition at line 314 of file actctx.c.

Referenced by test_actctx(), test_findsectionstring(), and test_ZombifyActCtx().

testlib2_dll

const WCHAR testlib2_dll[]

static

Initial value:

=
    {'t','e','s','t','l','i','b','2','.','d','l','l',0}

Definition at line 458 of file actctx.c.

Referenced by test_actctx(), and test_find_string_fail().

testlib_dll

const WCHAR testlib_dll[]

static

Initial value:

=
    {'t','e','s','t','l','i','b','.','d','l','l',0}

Definition at line 456 of file actctx.c.

Referenced by test_actctx(), and test_find_string_fail().

ULONG

const GUID ULONG

Definition at line 36 of file actctx.c.

Referenced by find_comserver_redirection(), find_progid_redirection(), find_tlib_redirection(), and lookup_manifest_file().

ULONG_PTR

ULONG_PTR

Definition at line 35 of file actctx.c.

wndClass1W

const WCHAR wndClass1W[]

static

Initial value:

=
    {'w','n','d','C','l','a','s','s','1',0}

Definition at line 462 of file actctx.c.

Referenced by test_wndclass_section().

wndClass2W

const WCHAR wndClass2W[]

static

Initial value:

=
    {'w','n','d','C','l','a','s','s','2',0}

Definition at line 464 of file actctx.c.

Referenced by test_actctx().

wndClass3W

const WCHAR wndClass3W[]

static

Initial value:

=
    {'w','n','d','C','l','a','s','s','3',0}

Definition at line 466 of file actctx.c.

Referenced by test_wndclass_section().

wndClassW

const WCHAR wndClassW[]

static

Initial value:

=
    {'w','n','d','C','l','a','s','s',0}

Definition at line 460 of file actctx.c.

Referenced by test_actctx().

work_dir

WCHAR work_dir[MAX_PATH]

static

Definition at line 469 of file actctx.c.

Referenced by init_paths(), test_actctx(), and test_CreateActCtx().

work_dir_subdir

WCHAR work_dir_subdir[MAX_PATH]

static

Definition at line 469 of file actctx.c.

Referenced by init_paths(), and test_actctx().

wrong_depmanifest1

const char wrong_depmanifest1[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity type=\"win32\" name=\"testdep\" version=\"6.5.4.4\" processorArchitecture=\"" ARCH "\" />"
"</assembly>"

Definition at line 400 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest1

const char wrong_manifest1[]

static

Initial value:

=
"<assembly manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"</assembly>"

Definition at line 324 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest10

const char wrong_manifest10[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel level=\"requireAdministrator\"/>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel uiAccess=\"true\"/>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"</assembly>"

Definition at line 381 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest2

const char wrong_manifest2[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"</assembly>"

Definition at line 329 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest3

const char wrong_manifest3[]

static

Initial value:

=
"<assembly test=\"test\" xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"</assembly>"

Definition at line 334 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest4

const char wrong_manifest4[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<test></test>"
"</assembly>"

Definition at line 339 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest5

const char wrong_manifest5[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"</assembly>"
"<test></test>"

Definition at line 345 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest6

const char wrong_manifest6[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v5\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"</assembly>"

Definition at line 351 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest7

const char wrong_manifest7[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity type=\"win32\" name=\"testdep\" version=\"6.5.4.3\" processorArchitecture=\"" ARCH "\" />"
"<file name=\"testlib.dll\" hash=\"63c978c2b53d6cf72b42fb7308f9af12ab19ec5\" hashalg=\"SHA1\" />"
"</assembly>"

Definition at line 356 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest8

const char wrong_manifest8[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.2.3.4\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<file></file>"
"</assembly>"

Definition at line 362 of file actctx.c.

Referenced by test_create_fail().

wrong_manifest9

const char wrong_manifest9[]

static

Initial value:

=
"<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
"<assemblyIdentity version=\"1.0.0.0\"  name=\"Wine.Test\" type=\"win32\"></assemblyIdentity>"
"<trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v2\">"
"    <security>"
"        <requestedPrivileges>"
"            <requestedExecutionLevel level=\"requireAdministrator\"/>"
"            <requestedExecutionLevel uiAccess=\"true\"/>"
"        </requestedPrivileges>"
"    </security>"
"</trustInfo>"
"</assembly>"

Definition at line 368 of file actctx.c.

Referenced by test_create_fail().