comtest.c File Reference

#include <stdio.h>
#include "windows.h"
#include "ole2.h"
#include "mscoree.h"
#include "corerror.h"
#include "shlwapi.h"
#include "shlobj.h"
#include "wine/test.h"
#include "initguid.h"
#include "interfaces.h"

Include dependency graph for comtest.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Typedefs
typedef enum _run_type	run_type

Enumerations
enum	_run_type { run_type_current_working_directory = 0 , run_type_exe_directory , run_type_system32 }

Functions
	DEFINE_GUID (IID_ITest2, 0x50adb433, 0xf6c5, 0x3b30, 0x92, 0x0a, 0x55, 0x57, 0x11, 0x86, 0x75, 0x09)
static BOOL	write_resource_file (const char *path_tmp, const char *name_res, const char *name_file, char *path_file)
static BOOL	compile_cs_to_dll (char *source_path, char *dest_path)
static void	run_test (BOOL expect_success)
static void	run_registry_test (run_type run)
static void	get_dll_path_for_run (char *path_dll, UINT path_dll_size, run_type run)
static void	prepare_and_run_test (const char *dll_source, run_type run)
static void	cleanup_test (run_type run)
static void	run_child_process (const char *dll_source, run_type run)
	START_TEST (comtest)

Variables
HMODULE	hmscoree

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 19 of file comtest.c.

Typedef Documentation

run_type

typedef enum _run_type run_type

Enumeration Type Documentation

_run_type

enum _run_type

Enumerator
run_type_current_working_directory
run_type_exe_directory
run_type_system32

Definition at line 38 of file comtest.c.

{
    run_type_current_working_directory = 0,
    run_type_exe_directory,
    run_type_system32,
} run_type;

Function Documentation

cleanup_test()

static void cleanup_test ( run_type  run )

static

Definition at line 337 of file comtest.c.

{
    char path_dll[MAX_PATH];
    BOOL success;
 
    get_dll_path_for_run(path_dll, sizeof(path_dll), run);
 
    if (!PathFileExistsA(path_dll))
        return;
 
    success = DeleteFileA(path_dll);
    if (!success)
    {
        Sleep(500);
        success = DeleteFileA(path_dll);
    }
    ok(success, "DeleteFileA failed: %ld\n", GetLastError());
}

compile_cs_to_dll()

static BOOL compile_cs_to_dll ( char *  source_path, char *  dest_path  )

static

Definition at line 73 of file comtest.c.

{
    const char *path_csc = "C:\\windows\\Microsoft.NET\\Framework\\v2.0.50727\\csc.exe";
    char cmdline[2 * MAX_PATH + 74];
    char path_temp[MAX_PATH];
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    BOOL ret;
 
    if (!PathFileExistsA(path_csc))
    {
        skip("Can't find csc.exe\n");
        return FALSE;
    }
 
    GetTempPathA(MAX_PATH, path_temp);
    PathAppendA(path_temp, "comtest.dll");
 
    sprintf(cmdline, "%s /t:library /out:\"%s\" \"%s\"", path_csc, path_temp, source_path);
 
    si.cb = sizeof(si);
    ret = CreateProcessA(path_csc, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "Could not create process: %lu\n", GetLastError());
 
    wait_child_process(pi.hProcess);
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
 
    ret = PathFileExistsA(path_temp);
    ok(ret, "Compilation failed\n");
 
    ret = MoveFileA(path_temp, dest_path);
    ok(ret, "Could not move %s to %s: %lu\n", path_temp, dest_path, GetLastError());
    return ret;
}

Referenced by prepare_and_run_test().

DEFINE_GUID()

DEFINE_GUID	(	IID_ITest2	,
		0x50adb433	,
		0xf6c5	,
		0x3b30	,
		0x92	,
		0x0a	,
		0x55	,
		0x57	,
		0x11	,
		0x86	,
		0x75	,
		0x09
	)

get_dll_path_for_run()

static void get_dll_path_for_run ( char *  path_dll, UINT  path_dll_size, run_type  run  )

static

Definition at line 211 of file comtest.c.

{
    char path_tmp[MAX_PATH];
 
    GetTempPathA(MAX_PATH, path_tmp);
 
    switch (run)
    {
    case run_type_current_working_directory:
       strcpy(path_dll, path_tmp);
       PathAppendA(path_dll, "comtest.dll");
       break;
    case run_type_exe_directory:
       GetModuleFileNameA(NULL, path_dll, path_dll_size);
       PathRemoveFileSpecA(path_dll);
       PathAppendA(path_dll, "comtest.dll");
       break;
    case run_type_system32:
       GetSystemDirectoryA(path_dll, path_dll_size);
       PathAppendA(path_dll, "comtest.dll");
       break;
    }
}

Referenced by cleanup_test(), and prepare_and_run_test().

prepare_and_run_test()

static void prepare_and_run_test ( const char *  dll_source, run_type  run  )

static

Definition at line 234 of file comtest.c.

{
    char path_tmp[MAX_PATH];
    char path_tmp_manifest[MAX_PATH];
    char path_dll[MAX_PATH];
    char path_dll_source[MAX_PATH];
    char path_manifest_dll[MAX_PATH];
    char path_manifest_exe[MAX_PATH];
    BOOL success;
    ACTCTXA context = {0};
    ULONG_PTR cookie;
    HANDLE handle_context = 0;
 
    path_manifest_exe[0] = path_manifest_dll[0] = path_dll_source[0] = 0;
 
    GetTempPathA(MAX_PATH, path_tmp);
    GetTempPathA(MAX_PATH, path_tmp_manifest);
    PathAppendA(path_tmp_manifest, "manifests");
 
    CreateDirectoryA(path_tmp_manifest, NULL);
 
    if (run == run_type_system32)
    {
        if (!IsUserAnAdmin())
        {
            skip("Can't test dll in system32 due to user not being admin.\n");
            return;
        }
    }
 
    if (!write_resource_file(path_tmp, dll_source, "comtest.cs", path_dll_source))
    {
        ok(0, "run: %d, Failed to create file for testing\n", run);
        goto cleanup;
    }
 
    get_dll_path_for_run(path_dll, sizeof(path_dll), run);
 
    if (!compile_cs_to_dll(path_dll_source, path_dll))
        goto cleanup;
 
    if (!write_resource_file(path_tmp_manifest, "comtest_exe.manifest", "exe.manifest", path_manifest_exe))
    {
        ok(0, "run: %d, Failed to create file for testing\n", run);
        goto cleanup;
    }
 
    if (!write_resource_file(path_tmp_manifest, "comtest_dll.manifest", "comtest.manifest", path_manifest_dll))
    {
        ok(0, "run: %d, Failed to create file for testing\n", run);
        goto cleanup;
    }
 
    context.cbSize = sizeof(ACTCTXA);
    context.lpSource = path_manifest_exe;
    context.lpAssemblyDirectory = path_tmp_manifest;
    context.dwFlags = ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID;
 
    handle_context = CreateActCtxA(&context);
    ok(handle_context != NULL && handle_context != INVALID_HANDLE_VALUE, "run: %d, CreateActCtxA failed: %ld\n", run, GetLastError());
 
    if (handle_context == NULL || handle_context == INVALID_HANDLE_VALUE)
    {
        ok(0, "run: %d, Failed to create activation context\n", run);
        goto cleanup;
    }
 
    success = ActivateActCtx(handle_context, &cookie);
    ok(success, "run: %d, ActivateActCtx failed: %ld\n", run,  GetLastError());
 
    if (run == run_type_current_working_directory)
        SetCurrentDirectoryA(path_tmp);
 
    run_test(run == run_type_exe_directory);
    run_registry_test(run);
 
cleanup:
    if (handle_context != NULL && handle_context != INVALID_HANDLE_VALUE)
    {
        success = DeactivateActCtx(0, cookie);
        ok(success, "run: %d, DeactivateActCtx failed: %ld\n", run, GetLastError());
        ReleaseActCtx(handle_context);
    }
    if (*path_manifest_exe)
    {
        success = DeleteFileA(path_manifest_exe);
        ok(success, "run: %d, DeleteFileA failed: %ld\n", run, GetLastError());
    }
    if(*path_manifest_dll)
    {
        success = DeleteFileA(path_manifest_dll);
        ok(success, "run: %d, DeleteFileA failed: %ld\n", run, GetLastError());
    }
    if(*path_dll_source)
    {
        success = DeleteFileA(path_dll_source);
        ok(success, "run: %d, DeleteFileA failed: %ld\n", run, GetLastError());
    }
    RemoveDirectoryA(path_tmp_manifest);
    /* dll cleanup is handled by the parent, because it might still be used by the child */
}

run_child_process()

static void run_child_process ( const char *  dll_source, run_type  run  )

static

Definition at line 356 of file comtest.c.

{
    char cmdline[MAX_PATH];
    char exe[MAX_PATH];
    char **argv;
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    BOOL ret;
 
    winetest_get_mainargs(&argv);
 
    if (strstr(argv[0], ".exe"))
        sprintf(exe, "%s", argv[0]);
    else
        sprintf(exe, "%s.exe", argv[0]);
    sprintf(cmdline, "\"%s\" %s %s %d", argv[0], argv[1], dll_source, run);
 
    si.cb = sizeof(si);
    ret = CreateProcessA(exe, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "Could not create process: %lu\n", GetLastError());
 
    wait_child_process(pi.hProcess);
 
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
 
    /* Cleanup dll, because it might still have been used by the child */
    cleanup_test(run);
}

run_registry_test()

static void run_registry_test ( run_type  run )

static

Definition at line 156 of file comtest.c.

{
    char buffer[256];
    ITest *test = NULL;
    HRESULT hr, result_expected;
    IUnknown *unk = NULL;
    HKEY hkey;
    DWORD ret;
    int i = 0;
 
    if (run == run_type_exe_directory) result_expected = S_OK;
    else result_expected = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    sprintf(buffer, "CLSID\\%s", wine_dbgstr_guid(&CLSID_Test));
    ret = RegCreateKeyA( HKEY_CLASSES_ROOT, buffer, &hkey );
    if (ret == ERROR_ACCESS_DENIED && !IsUserAnAdmin())
    {
        win_skip("cannot run the registry tests due to user not being admin\n");
        RegCloseKey(hkey);
        return;
    }
    ok(ret == ERROR_SUCCESS, "RegCreateKeyA returned %lx\n", ret);
 
    ret = RegSetKeyValueA(hkey, "InprocServer32", NULL, REG_SZ, "mscoree.dll", 11);
    ok(ret == ERROR_SUCCESS, "RegSetKeyValueA returned %lx\n", ret);
    ret = RegSetKeyValueA(hkey, "InprocServer32", "Assembly", REG_SZ, "comtest, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", 74);
    ok(ret == ERROR_SUCCESS, "RegSetKeyValueA returned %lx\n", ret);
    ret = RegSetKeyValueA(hkey, "InprocServer32", "Class", REG_SZ, "DLL.Test", 8);
    ok(ret == ERROR_SUCCESS, "RegSetKeyValueA returned %lx\n", ret);
    ret = RegSetKeyValueA(hkey, "InprocServer32", "CodeBase", REG_SZ, "file:///U:/invalid/path/to/comtest.dll", 41);
    ok(ret == ERROR_SUCCESS, "RegSetKeyValueA returned %lx\n", ret);
 
    hr = CoCreateInstance(&CLSID_Test, NULL, CLSCTX_INPROC_SERVER, &IID_ITest, (void**)&test);
    todo_wine_if(result_expected != S_OK)
    ok(hr == result_expected, "Expected %lx, got %lx\n", result_expected, hr);
 
    if (hr == S_OK)
    {
        hr = ITest_Func(test, &i);
        ok(hr == S_OK, "Got %lx\n", hr);
        ok(i == 42, "Expected 42, got %d\n", i);
        hr = ITest_QueryInterface(test, &IID_ITest2, (void**)&unk);
        ok(hr == S_OK, "ITest_QueryInterface returned %lx\n", hr);
        if (hr == S_OK) IUnknown_Release(unk);
        ITest_Release(test);
    }
 
    RegDeleteKeyValueA(hkey, "InprocServer32", "CodeBase");
    RegDeleteKeyValueA(hkey, "InprocServer32", "Class");
    RegDeleteKeyValueA(hkey, "InprocServer32", "Assembly");
    RegDeleteKeyValueA(hkey, "InprocServer32", NULL);
    RegDeleteKeyA(hkey, "InprocServer32");
    RegCloseKey(hkey);
}

Referenced by prepare_and_run_test().

run_test()

static void run_test ( BOOL  expect_success )

static

Definition at line 109 of file comtest.c.

{
    typedef HRESULT (WINAPI *_DllGetClassObject)(REFCLSID rclsid, REFIID riid, LPVOID *ppv);
    ITest *test = NULL;
    HRESULT hr;
    _DllGetClassObject getClassObject;
    IClassFactory *classFactory = NULL;
    HRESULT result_expected = expect_success ? S_OK : HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 
    hr = CoCreateInstance(&CLSID_Test, NULL, CLSCTX_INPROC_SERVER, &IID_ITest, (void**)&test);
    todo_wine_if(!expect_success)
    ok(hr == result_expected, "Expected %lx, got %lx\n", result_expected, hr);
 
    if (hr == S_OK)
    {
        int i = 0;
        hr = ITest_Func(test, &i);
        ok(hr == S_OK, "Got %lx\n", hr);
        ok(i == 42, "Expected 42, got %d\n", i);
        ITest_Release(test);
    }
 
    getClassObject = (_DllGetClassObject)GetProcAddress(hmscoree, "DllGetClassObject");
    hr = getClassObject(&CLSID_Test, &IID_IClassFactory, (void **)&classFactory);
    todo_wine_if(!expect_success)
    ok(hr == result_expected, "Expected %lx, got %lx\n", result_expected, hr);
 
    if (hr == S_OK)
    {
        ITest *test2 = NULL;
        hr = IClassFactory_CreateInstance(classFactory, NULL, &IID_ITest, (void **)&test2);
        todo_wine_if(!expect_success)
        ok(hr == S_OK, "Got %lx\n", hr);
 
        if (hr == S_OK)
        {
            int i = 0;
            hr = ITest_Func(test2, &i);
            ok(hr == S_OK, "Got %lx\n", hr);
            ok(i == 42, "Expected 42, got %d\n", i);
            ITest_Release(test2);
        }
        IClassFactory_Release(classFactory);
    }
 
}

START_TEST()

START_TEST

(

comtest

)

Definition at line 386 of file comtest.c.

{
    int argc;
    char **argv;
 
    CoInitialize(NULL);
 
    hmscoree = LoadLibraryA("mscoree.dll");
    if (!hmscoree)
    {
        skip(".NET or mono not available\n");
        return;
    }
 
    argc = winetest_get_mainargs(&argv);
    if (argc > 2)
    {
        const char *dll_source = argv[2];
        run_type run = atoi(argv[3]);
        prepare_and_run_test(dll_source, run);
 
        goto cleanup;
    }
 
    run_child_process("comtest.cs", run_type_current_working_directory);
    run_child_process("comtest.cs", run_type_exe_directory);
    run_child_process("comtest.cs", run_type_system32);
 
cleanup:
    FreeLibrary(hmscoree);
    CoUninitialize();
}

write_resource_file()

static BOOL write_resource_file ( const char *  path_tmp, const char *  name_res, const char *  name_file, char *  path_file  )

static

Definition at line 45 of file comtest.c.

{
    HRSRC rsrc;
    void *rsrc_data;
    DWORD rsrc_size;
    BOOL ret;
    HANDLE hfile;
 
    rsrc = FindResourceA(GetModuleHandleA(NULL), name_res, (LPCSTR)RT_RCDATA);
    if (!rsrc) return FALSE;
 
    rsrc_data = LockResource(LoadResource(GetModuleHandleA(NULL), rsrc));
    if (!rsrc_data) return FALSE;
 
    rsrc_size = SizeofResource(GetModuleHandleA(NULL), rsrc);
    if (!rsrc_size) return FALSE;
 
    strcpy(path_file, path_tmp);
    PathAppendA(path_file, name_file);
    hfile = CreateFileA(path_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    if (hfile == INVALID_HANDLE_VALUE) return FALSE;
 
    ret = WriteFile(hfile, rsrc_data, rsrc_size, &rsrc_size, NULL);
 
    CloseHandle(hfile);
    return ret;
}

Referenced by prepare_and_run_test().

Variable Documentation

hmscoree

HMODULE hmscoree

Definition at line 34 of file comtest.c.

Referenced by run_test(), and START_TEST().