ole32: Add a basic OLE client/server test suite. Take 2.
Dmitry Timoshkov
dmitry at baikal.ru
Tue May 28 22:07:15 CDT 2013
With minor clean ups and with increased timeout to wait for server termination
to please some really slow VMs (that allowed to remove broken() statements).
---
dlls/ole32/tests/Makefile.in | 1 +
dlls/ole32/tests/ole_server.c | 635 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 636 insertions(+)
create mode 100644 dlls/ole32/tests/ole_server.c
diff --git a/dlls/ole32/tests/Makefile.in b/dlls/ole32/tests/Makefile.in
index 6e88987..39e102f 100644
--- a/dlls/ole32/tests/Makefile.in
+++ b/dlls/ole32/tests/Makefile.in
@@ -11,6 +11,7 @@ C_SRCS = \
marshal.c \
moniker.c \
ole2.c \
+ ole_server.c \
propvariant.c \
stg_prop.c \
storage32.c \
diff --git a/dlls/ole32/tests/ole_server.c b/dlls/ole32/tests/ole_server.c
new file mode 100644
index 0000000..2e7afd4
--- /dev/null
+++ b/dlls/ole32/tests/ole_server.c
@@ -0,0 +1,635 @@
+/*
+ * OLE client/server test suite
+ *
+ * Copyright 2013 Dmitry Timoshkov
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+#define CONST_VTABLE
+
+#include <windows.h>
+#include <exdisp.h>
+#include <tlhelp32.h>
+#include <stdio.h>
+#include <assert.h>
+#include "wine/test.h"
+
+#include <initguid.h>
+DEFINE_GUID(CLSID_WineTestObject, 0xdeadbeef,0xdead,0xbeef,0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef);
+#ifndef CLSID_IdentityUnmarshal
+DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
+#endif
+DEFINE_GUID(CLSID_UnknownUnmarshal,0x4c1e39e1,0xe3e3,0x4296,0xaa,0x86,0xec,0x93,0x8d,0x89,0x6e,0x92);
+
+struct winetest_info
+{
+ DWORD parent_pid;
+ HANDLE write_end, mutex;
+};
+
+static char *argv0;
+static const char *current_file;
+static int current_line;
+static HANDLE done_event, read_end, write_end, mutex;
+
+static const struct
+{
+ const GUID *guid;
+ const char *name;
+} guid_name[] =
+{
+#define GUID_NAME(guid) \
+ { &IID_##guid, #guid }
+ GUID_NAME(IUnknown),
+ GUID_NAME(IClassFactory),
+ GUID_NAME(IOleObject),
+ GUID_NAME(IMarshal),
+ GUID_NAME(IStdMarshalInfo),
+ GUID_NAME(IExternalConnection),
+ GUID_NAME(IRunnableObject),
+ { &CLSID_IdentityUnmarshal, "CLSID_IdentityUnmarshal" },
+ { &CLSID_UnknownUnmarshal, "CLSID_UnknownUnmarshal" },
+#undef GUID_NAME
+};
+
+static const char *debugstr_guid(const GUID *guid)
+{
+ static char buf[50];
+ int i;
+
+ if (!guid) return "(null)";
+
+ for (i = 0; i < sizeof(guid_name)/sizeof(guid_name[0]); i++)
+ {
+ if (IsEqualIID(guid, guid_name[i].guid))
+ return guid_name[i].name;
+ }
+
+ sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
+ guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
+ guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
+ guid->Data4[5], guid->Data4[6], guid->Data4[7]);
+ return buf;
+}
+
+/******************************* OLE server *******************************/
+static LONG server_locks;
+
+static void server_set_location(const char *file, int line)
+{
+ current_file = strrchr(file, '/');
+ if (!current_file)
+ current_file = strrchr(file, '\\');
+ if (!current_file)
+ current_file = file;
+ else
+ current_file++;
+ current_line = line;
+}
+
+#undef trace_
+#define trace_(file, line) (server_set_location(file, line), 0) ? (void)0 : server_trace
+static void server_trace(const char *msg, ...)
+{
+ if (winetest_debug > 0)
+ {
+ va_list valist;
+ char buf[1024];
+ DWORD ret;
+
+ WaitForSingleObject(mutex, INFINITE);
+
+ sprintf(buf, "%s:%d:server: ", current_file, current_line );
+ WriteFile(write_end, buf, strlen(buf), &ret, NULL);
+
+ va_start(valist, msg);
+ vsprintf(buf, msg, valist);
+ va_end(valist);
+ WriteFile(write_end, buf, strlen(buf), &ret, NULL);
+
+ ReleaseMutex(mutex);
+ }
+}
+
+typedef struct
+{
+ IUnknown IUnknown_iface;
+ LONG ref;
+} UnknownImpl;
+
+static inline UnknownImpl *impl_from_IUnknown(IUnknown *iface)
+{
+ return CONTAINING_RECORD(iface, UnknownImpl, IUnknown_iface);
+}
+
+static HRESULT WINAPI UnknownImpl_QueryInterface(IUnknown *iface,
+ REFIID iid, void **ppv)
+{
+ UnknownImpl *This = impl_from_IUnknown(iface);
+
+ trace("unknown_QueryInterface: %p,%s,%p\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid))
+ {
+ *ppv = &This->IUnknown_iface;
+ IUnknown_AddRef(&This->IUnknown_iface);
+ return S_OK;
+ }
+
+ *ppv = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI UnknownImpl_AddRef(IUnknown *iface)
+{
+ UnknownImpl *This = impl_from_IUnknown(iface);
+ ULONG ref = InterlockedIncrement(&This->ref);
+
+ trace("unknown_AddRef: %p, ref %u\n", iface, ref);
+ return ref;
+}
+
+static ULONG WINAPI UnknownImpl_Release(IUnknown *iface)
+{
+ UnknownImpl *This = impl_from_IUnknown(iface);
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ trace("unknown_Release: %p, ref %u\n", iface, ref);
+
+ if (ref == 0)
+ {
+ HeapFree(GetProcessHeap(), 0, This);
+ if (!server_locks)
+ {
+ trace("signalling termination\n");
+ SetEvent(done_event);
+ }
+ }
+ return ref;
+}
+
+static const IUnknownVtbl UnknownImpl_Vtbl =
+{
+ UnknownImpl_QueryInterface,
+ UnknownImpl_AddRef,
+ UnknownImpl_Release,
+};
+
+typedef struct
+{
+ IClassFactory IClassFactory_iface;
+ LONG ref;
+} ClassFactoryImpl;
+
+static inline ClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
+{
+ return CONTAINING_RECORD(iface, ClassFactoryImpl, IClassFactory_iface);
+}
+
+static HRESULT WINAPI ClassFactoryImpl_QueryInterface(IClassFactory *iface,
+ REFIID iid, void **ppv)
+{
+ ClassFactoryImpl *This = impl_from_IClassFactory(iface);
+
+ trace("factory_QueryInterface: %p,%s,%p\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid) ||
+ IsEqualIID(&IID_IClassFactory, iid))
+ {
+ IClassFactory_AddRef(&This->IClassFactory_iface);
+ *ppv = &This->IClassFactory_iface;
+ return S_OK;
+ }
+
+ *ppv = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI ClassFactoryImpl_AddRef(IClassFactory *iface)
+{
+ trace("factory_AddRef: %p, returning 2\n", iface);
+ return 2;
+}
+
+static ULONG WINAPI ClassFactoryImpl_Release(IClassFactory *iface)
+{
+ trace("factory_Release: %p, returning 1\n", iface);
+ return 1;
+}
+
+static HRESULT WINAPI ClassFactoryImpl_CreateInstance(IClassFactory *iface,
+ IUnknown *punkouter, REFIID iid, void **ppv)
+{
+ UnknownImpl *unknown;
+ HRESULT hr;
+
+ trace("factory_CreateInstance: %p,%s,%p\n", iface, debugstr_guid(iid), ppv);
+
+ if (punkouter) return CLASS_E_NOAGGREGATION;
+
+ unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(UnknownImpl));
+ if (!unknown) return E_OUTOFMEMORY;
+
+ unknown->IUnknown_iface.lpVtbl = &UnknownImpl_Vtbl;
+ unknown->ref = 1;
+
+ hr = IUnknown_QueryInterface(&unknown->IUnknown_iface, iid, ppv);
+ IUnknown_Release(&unknown->IUnknown_iface);
+
+ return hr;
+}
+
+static HRESULT WINAPI ClassFactoryImpl_LockServer(IClassFactory *iface, BOOL lock)
+{
+ trace("factory_LockServer: %p,%d\n", iface, lock);
+
+ if (lock)
+ InterlockedIncrement(&server_locks);
+ else
+ {
+ ULONG ref = InterlockedDecrement(&server_locks);
+ if (!ref)
+ {
+ trace("signalling termination\n");
+ SetEvent(done_event);
+ }
+ }
+
+ return S_OK;
+}
+
+static const IClassFactoryVtbl ClassFactoryImpl_Vtbl =
+{
+ ClassFactoryImpl_QueryInterface,
+ ClassFactoryImpl_AddRef,
+ ClassFactoryImpl_Release,
+ ClassFactoryImpl_CreateInstance,
+ ClassFactoryImpl_LockServer
+};
+
+static ClassFactoryImpl factory = { { &ClassFactoryImpl_Vtbl }, 0 };
+
+static DWORD WINAPI server_thread_proc(void *param)
+{
+ HRESULT hr;
+ DWORD key;
+
+ trace("%04u: server_thread_proc: starting\n", GetCurrentThreadId());
+
+ hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+ if (hr == S_OK)
+ {
+ trace("registering class object\n");
+ hr = CoRegisterClassObject(&CLSID_WineTestObject, (IUnknown *)&factory,
+ CLSCTX_SERVER, REGCLS_SINGLEUSE, &key);
+ if (hr == S_OK)
+ {
+ done_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+ trace("waiting for requests\n");
+ WaitForSingleObject(done_event, INFINITE);
+ CloseHandle(done_event);
+#if 0
+ /* calling CoRevokeClassObject terminates process under Win7 */
+ trace("call CoRevokeClassObject\n");
+ CoRevokeClassObject(key);
+ trace("ret CoRevokeClassObject\n");
+#endif
+ }
+ trace("call CoUninitialize\n");
+ CoUninitialize();
+ trace("ret CoUninitialize\n");
+ }
+
+ trace("%04u: server_thread_proc: exiting\n", GetCurrentThreadId());
+ return 1234;
+}
+
+static void ole_server(void)
+{
+ HANDLE thread;
+ DWORD ret;
+ HANDLE mapping, parent_process;
+ struct winetest_info *info;
+
+ mapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_ole_server");
+ info = MapViewOfFile(mapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 4096);
+ parent_process = OpenProcess(PROCESS_DUP_HANDLE | SYNCHRONIZE, FALSE, info->parent_pid);
+ DuplicateHandle(parent_process, info->write_end, GetCurrentProcess(), &write_end,
+ 0, FALSE, DUPLICATE_SAME_ACCESS);
+ DuplicateHandle(parent_process, info->mutex, GetCurrentProcess(), &mutex,
+ 0, FALSE, DUPLICATE_SAME_ACCESS);
+ CloseHandle(parent_process);
+
+ trace("starting %u\n", GetCurrentProcessId());
+
+ thread = CreateThread(NULL, 0, server_thread_proc, NULL, 0, &ret);
+ trace("waiting for thread termination\n");
+ WaitForSingleObject(thread, INFINITE);
+ GetExitCodeThread(thread, &ret);
+ trace("thread exit code %u\n", ret);
+ CloseHandle(thread);
+
+ trace("exiting %u\n", GetCurrentProcessId());
+ ExitProcess(0);
+}
+
+/******************************* OLE client *******************************/
+
+static void flush_server_output(void)
+{
+ char buf[4096];
+ DWORD bytes, ret;
+
+ WaitForSingleObject(mutex, INFINITE);
+
+ ret = PeekNamedPipe(read_end, NULL, 0, NULL, &bytes, NULL);
+ assert(bytes <= sizeof(buf));
+ if (ret && bytes && ReadFile(read_end, buf, sizeof(buf), &bytes, NULL))
+ {
+ fwrite(buf, 1, bytes, stdout);
+ fflush(stdout);
+ }
+
+ ReleaseMutex(mutex);
+}
+
+#undef trace_
+#define trace_(file, line) (server_set_location(file, line), 0) ? (void)0 : client_trace
+static void client_trace(const char *msg, ...)
+{
+ flush_server_output();
+
+ if (winetest_debug > 0)
+ {
+ va_list valist;
+
+ fprintf(stdout, "%s:%d:client: ", current_file, current_line);
+ va_start(valist, msg);
+ vfprintf(stdout, msg, valist);
+ va_end(valist);
+ }
+}
+
+static int get_server_pid(void)
+{
+ HANDLE snap;
+ BOOL ret;
+ PROCESSENTRY32 pe;
+ DWORD server_pid = 0;
+
+ /* some really slow VMs still list the terminated server,
+ * give them a chance to clean up.
+ */
+ Sleep(1000);
+
+ snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+ ok(snap != INVALID_HANDLE_VALUE, "CreateToolhelp32Snapshot error %d\n", GetLastError());
+
+ pe.dwSize = sizeof(pe);
+ ret = Process32First(snap, &pe);
+ while (ret)
+ {
+ /*trace("pid %u, file name %s\n", pe.th32ProcessID, pe.szExeFile);*/
+ if (pe.th32ProcessID != GetCurrentProcessId() && !lstrcmpi(pe.szExeFile, argv0))
+ {
+ trace("pid %u, file name %s\n", pe.th32ProcessID, pe.szExeFile);
+ server_pid = pe.th32ProcessID;
+ break;
+ }
+ ret = Process32Next(snap, &pe);
+ }
+ CloseHandle(snap);
+
+ return server_pid;
+}
+
+static void terminate_process(DWORD pid)
+{
+ HANDLE process;
+ DWORD ret;
+
+ process = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE, FALSE, pid);
+ ok(process != 0, "OpenProcess error %d\n", GetLastError());
+ ret = TerminateProcess(process, 0);
+ ok(ret, "TerminateProcess() error %d\n", GetLastError());
+ ret = WaitForSingleObject(process, 1000);
+ ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed: %#x\n", ret);
+
+ CloseHandle(process);
+}
+
+static void wait_for_termination(DWORD pid)
+{
+ HANDLE process;
+ DWORD ret;
+
+ process = OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE, FALSE, pid);
+ if (process)
+ {
+ ret = WaitForSingleObject(process, 10000);
+ if (ret == WAIT_OBJECT_0)
+ trace("process %u has terminated\n", pid);
+ else
+ trace("process %u failed to terminate\n", pid);
+ CloseHandle(process);
+ }
+ else
+ trace("OpenProcess(%u) error %d\n", GetLastError());
+
+ flush_server_output();
+}
+
+static BOOL register_server(const char *server)
+{
+ static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
+ DWORD ret;
+ HKEY root;
+ WCHAR buf[256];
+ char server_path[MAX_PATH];
+
+ lstrcpy(server_path, server);
+ lstrcat(server_path, " ole_server");
+
+ lstrcpyW(buf, clsidW);
+ StringFromGUID2(&CLSID_WineTestObject, buf + 6, 39);
+
+ ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
+ KEY_READ | KEY_WRITE | KEY_CREATE_SUB_KEY, NULL, &root, NULL);
+ if (ret == ERROR_SUCCESS)
+ {
+ ret = RegSetValue(root, "LocalServer32", REG_SZ, server_path, strlen(server_path));
+ ok(ret == ERROR_SUCCESS, "RegSetValue error %u\n", ret);
+ RegCloseKey(root);
+ }
+
+ return ret == ERROR_SUCCESS;
+}
+
+static void unregister_server(void)
+{
+ static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
+ DWORD ret;
+ HKEY root;
+ WCHAR buf[39 + 6];
+
+ lstrcpyW(buf, clsidW);
+ StringFromGUID2(&CLSID_WineTestObject, buf + 6, 39);
+
+ ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
+ DELETE, NULL, &root, NULL);
+ if (ret == ERROR_SUCCESS)
+ {
+ ret = RegDeleteKey(root, "LocalServer32");
+ ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
+ ret = RegDeleteKey(root, "");
+ ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
+ RegCloseKey(root);
+ }
+}
+
+START_TEST(ole_server)
+{
+ CLSID clsid = CLSID_WineTestObject;
+ HRESULT hr;
+ IUnknown *unknown;
+ IOleObject *oleobj;
+ IClassFactory *factory;
+ DWORD ret;
+ HANDLE mapping;
+ struct winetest_info *info;
+ int argc;
+ char **argv, *ext;
+
+ argc = winetest_get_mainargs(&argv);
+ argv0 = strrchr(argv[0], '\\');
+ if (!argv0) argv0 = strrchr(argv[0], '/');
+ if (!argv0) argv0 = argv[0];
+ else argv0++;
+ argv0 = strdup(argv0);
+ ext = strrchr(argv0, '.');
+ if (ext && !lstrcmpi(ext, ".so")) *ext = 0;
+
+ if (argc > 1 && !lstrcmpi(argv[2], "-Embedding"))
+ {
+ ole_server();
+ return;
+ }
+
+ if (!register_server(argv[0]))
+ {
+ win_skip("not enough permissions to create a server CLSID key\n");
+ return;
+ }
+
+ CreatePipe(&read_end, &write_end, NULL, 0);
+
+ mapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_ole_server");
+ ok(mapping != 0, "CreateFileMapping failed\n");
+ info = MapViewOfFile(mapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 4096);
+ info->parent_pid = GetCurrentProcessId();
+ info->write_end = write_end;
+ mutex = info->mutex = CreateMutex(NULL, FALSE, NULL);
+
+ ret = get_server_pid();
+ ok(!ret, "server should not be running (pid %u)\n", ret);
+ if (ret) terminate_process(ret);
+
+ hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+ ok(hr == S_OK, "OleInitialize error %#x\n", hr);
+
+ hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&unknown);
+ ok(hr == REGDB_E_CLASSNOTREG, "expected REGDB_E_CLASSNOTREG, got %#x\n", hr);
+
+ ret = get_server_pid();
+ ok(!ret, "server should not be running (pid %u)\n", ret);
+
+ /* server supports IID_IUnknown */
+ trace("call CoCreateInstance(&IID_IUnknown)\n");
+ hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_IUnknown, (void **)&unknown);
+ trace("ret CoCreateInstance(&IID_IUnknown)\n");
+ ok(hr == S_OK, "CoCreateInstance(IID_IUnknown) error %#x\n", hr);
+
+ ret = get_server_pid();
+ ok(ret != 0, "server %s should be running\n", argv0);
+
+ trace("call IUnknown_QueryInterface(&IID_IRunnableObject)\n");
+ hr = IUnknown_QueryInterface(unknown, &IID_IRunnableObject, (void **)&oleobj);
+ trace("ret IUnknown_QueryInterface(&IID_IRunnableObject)\n");
+ ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
+
+ trace("call OleRun\n");
+ hr = OleRun(unknown);
+ trace("ret OleRun\n");
+ ok(hr == S_OK, "OleRun error %#x\n", hr);
+
+ trace("call IUnknown_QueryInterface(&IID_IOleObject)\n");
+ hr = IUnknown_QueryInterface(unknown, &IID_IOleObject, (void **)&oleobj);
+ trace("ret IUnknown_QueryInterface(&IID_IOleObject)\n");
+ ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
+
+ trace("call IUnknown_Release\n");
+ ret = IUnknown_Release(unknown);
+ trace("ret IUnknown_Release\n");
+ ok(!ret, "expected ref 0, got %u\n", ret);
+
+ ret = get_server_pid();
+ if (ret)
+ {
+ wait_for_termination(ret);
+ ret = get_server_pid();
+ }
+ ok(!ret, "server should not be running (pid %u)\n", ret);
+
+ trace("call CoGetClassObject(&IID_IClassFactory)\n");
+ hr = CoGetClassObject(&clsid, CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void **)&factory);
+ trace("ret CoGetClassObject(&IID_IClassFactory)\n");
+ ok(hr == S_OK, "CoGetClassObject error %#x\n", hr);
+
+ ret = get_server_pid();
+ ok(ret != 0, "server %s should be running\n", argv0);
+
+ trace("call IClassFactory_QueryInterface(&IID_IOleObject)\n");
+ hr = IClassFactory_QueryInterface(factory, &IID_IOleObject, (void **)&oleobj);
+ trace("ret IClassFactory_QueryInterface(&IID_IOleObject)\n");
+ ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
+
+ trace("call IClassFactory_CreateInstance(&IID_IOleObject)\n");
+ hr = IClassFactory_CreateInstance(factory, NULL, &IID_IOleObject, (void **)&oleobj);
+ trace("ret IClassFactory_CreateInstance(&IID_IOleObject)\n");
+ ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
+
+ trace("call IClassFactory_Release\n");
+ ret = IClassFactory_Release(factory);
+ trace("ret IClassFactory_Release\n");
+ ok(!ret, "expected ref 0, got %u\n", ret);
+
+ ret = get_server_pid();
+ if (ret)
+ {
+ wait_for_termination(ret);
+ ret = get_server_pid();
+ }
+ ok(!ret, "server should not be running (pid %u)\n", ret);
+
+ OleUninitialize();
+
+ unregister_server();
+}
--
1.8.3
More information about the wine-patches
mailing list