modules/rostests/winetests/ole32/ole_server.c

   1 /*
   2  * OLE client/server test suite
   3  *
   4  * Copyright 2013 Dmitry Timoshkov
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "precomp.h"
  22
  23 #include <initguid.h>
  24 DEFINE_GUID(CLSID_WineTestObject, 0xdeadbeef,0xdead,0xbeef,0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef);
  25 #ifndef CLSID_IdentityUnmarshal
  26 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  27 #endif
  28 DEFINE_GUID(CLSID_UnknownUnmarshal,0x4c1e39e1,0xe3e3,0x4296,0xaa,0x86,0xec,0x93,0x8d,0x89,0x6e,0x92);
  29
  30 struct winetest_info
  31 {
  32     LONG child_failures;
  33 };
  34
  35 static const struct
  36 {
  37     const GUID *guid;
  38     const char *name;
  39 } guid_name[] =
  40 {
  41 #define GUID_NAME(guid) \
  42     { &IID_##guid, #guid }
  43     GUID_NAME(IUnknown),
  44     GUID_NAME(IClassFactory),
  45     GUID_NAME(IOleObject),
  46     GUID_NAME(IMarshal),
  47     GUID_NAME(IStdMarshalInfo),
  48     GUID_NAME(IExternalConnection),
  49     GUID_NAME(IRunnableObject),
  50     GUID_NAME(ICallFactory),
  51     { &CLSID_IdentityUnmarshal, "CLSID_IdentityUnmarshal" },
  52     { &CLSID_UnknownUnmarshal, "CLSID_UnknownUnmarshal" },
  53 #undef GUID_NAME
  54 };
  55
  56 static LONG obj_ref, class_ref, server_locks;
  57
  58 static const char *debugstr_guid(const GUID *guid)
  59 {
  60     int i;
  61
  62     if (!guid) return "(null)";
  63
  64     for (i = 0; i < sizeof(guid_name)/sizeof(guid_name[0]); i++)
  65     {
  66         if (IsEqualIID(guid, guid_name[i].guid))
  67             return guid_name[i].name;
  68     }
  69
  70     return wine_dbgstr_guid(guid);
  71 }
  72
  73 /******************************* OLE server *******************************/
  74 typedef struct
  75 {
  76     IUnknown IUnknown_iface;
  77     LONG ref;
  78 } UnknownImpl;
  79
  80 static inline UnknownImpl *impl_from_IUnknown(IUnknown *iface)
  81 {
  82     return CONTAINING_RECORD(iface, UnknownImpl, IUnknown_iface);
  83 }
  84
  85 static HRESULT WINAPI UnknownImpl_QueryInterface(IUnknown *iface,
  86     REFIID iid, void **ppv)
  87 {
  88     UnknownImpl *This = impl_from_IUnknown(iface);
  89
  90     trace("server: unknown_QueryInterface: %p,%s,%p\n", iface, debugstr_guid(iid), ppv);
  91
  92     if (!ppv) return E_INVALIDARG;
  93
  94     if (IsEqualIID(&IID_IUnknown, iid))
  95     {
  96         *ppv = &This->IUnknown_iface;
  97         IUnknown_AddRef(&This->IUnknown_iface);
  98         return S_OK;
  99     }
 100
 101     *ppv = NULL;
 102     return E_NOINTERFACE;
 103 }
 104
 105 static ULONG WINAPI UnknownImpl_AddRef(IUnknown *iface)
 106 {
 107     UnknownImpl *This = impl_from_IUnknown(iface);
 108     ULONG ref = InterlockedIncrement(&This->ref);
 109
 110     InterlockedIncrement(&obj_ref);
 111
 112     trace("server: unknown_AddRef: %p, ref %u\n", iface, ref);
 113     return ref;
 114 }
 115
 116 static ULONG WINAPI UnknownImpl_Release(IUnknown *iface)
 117 {
 118     UnknownImpl *This = impl_from_IUnknown(iface);
 119     ULONG ref = InterlockedDecrement(&This->ref);
 120
 121     InterlockedDecrement(&obj_ref);
 122
 123     trace("server: unknown_Release: %p, ref %u\n", iface, ref);
 124     if (ref == 0) HeapFree(GetProcessHeap(), 0, This);
 125     return ref;
 126 }
 127
 128 static const IUnknownVtbl UnknownImpl_Vtbl =
 129 {
 130     UnknownImpl_QueryInterface,
 131     UnknownImpl_AddRef,
 132     UnknownImpl_Release,
 133 };
 134
 135 typedef struct
 136 {
 137     IClassFactory IClassFactory_iface;
 138     LONG ref;
 139 } ClassFactoryImpl;
 140
 141 static inline ClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
 142 {
 143     return CONTAINING_RECORD(iface, ClassFactoryImpl, IClassFactory_iface);
 144 }
 145
 146 static HRESULT WINAPI ClassFactoryImpl_QueryInterface(IClassFactory *iface,
 147     REFIID iid, void **ppv)
 148 {
 149     ClassFactoryImpl *This = impl_from_IClassFactory(iface);
 150
 151     trace("server: factory_QueryInterface: %p,%s,%p\n", iface, debugstr_guid(iid), ppv);
 152
 153     if (!ppv) return E_INVALIDARG;
 154
 155     if (IsEqualIID(&IID_IUnknown, iid) ||
 156         IsEqualIID(&IID_IClassFactory, iid))
 157     {
 158         IClassFactory_AddRef(&This->IClassFactory_iface);
 159         *ppv = &This->IClassFactory_iface;
 160         return S_OK;
 161     }
 162
 163     *ppv = NULL;
 164     return E_NOINTERFACE;
 165 }
 166
 167 static ULONG WINAPI ClassFactoryImpl_AddRef(IClassFactory *iface)
 168 {
 169     ClassFactoryImpl *This = impl_from_IClassFactory(iface);
 170     ULONG ref = InterlockedIncrement(&This->ref);
 171
 172     InterlockedIncrement(&class_ref);
 173
 174     trace("server: factory_AddRef: %p, ref %u\n", iface, ref);
 175     return ref;
 176 }
 177
 178 static ULONG WINAPI ClassFactoryImpl_Release(IClassFactory *iface)
 179 {
 180     ClassFactoryImpl *This = impl_from_IClassFactory(iface);
 181     ULONG ref = InterlockedDecrement(&This->ref);
 182
 183     InterlockedDecrement(&class_ref);
 184
 185     trace("server: factory_Release: %p, ref %u\n", iface, ref);
 186     return ref;
 187 }
 188
 189 static HRESULT WINAPI ClassFactoryImpl_CreateInstance(IClassFactory *iface,
 190     IUnknown *punkouter, REFIID iid, void **ppv)
 191 {
 192     UnknownImpl *unknown;
 193     HRESULT hr;
 194
 195     trace("server: factory_CreateInstance: %p,%s,%p\n", iface, debugstr_guid(iid), ppv);
 196
 197     if (punkouter) return CLASS_E_NOAGGREGATION;
 198
 199     unknown = HeapAlloc(GetProcessHeap(), 0, sizeof(*unknown));
 200     if (!unknown) return E_OUTOFMEMORY;
 201
 202     unknown->IUnknown_iface.lpVtbl = &UnknownImpl_Vtbl;
 203     unknown->ref = 0;
 204     IUnknown_AddRef(&unknown->IUnknown_iface);
 205
 206     hr = IUnknown_QueryInterface(&unknown->IUnknown_iface, iid, ppv);
 207     IUnknown_Release(&unknown->IUnknown_iface);
 208
 209     return hr;
 210 }
 211
 212 static HRESULT WINAPI ClassFactoryImpl_LockServer(IClassFactory *iface, BOOL lock)
 213 {
 214     ULONG ref = lock ? InterlockedIncrement(&server_locks) : InterlockedDecrement(&server_locks);
 215
 216     trace("server: factory_LockServer: %p,%d, ref %u\n", iface, lock, ref);
 217     return S_OK;
 218 }
 219
 220 static const IClassFactoryVtbl ClassFactoryImpl_Vtbl =
 221 {
 222     ClassFactoryImpl_QueryInterface,
 223     ClassFactoryImpl_AddRef,
 224     ClassFactoryImpl_Release,
 225     ClassFactoryImpl_CreateInstance,
 226     ClassFactoryImpl_LockServer
 227 };
 228
 229 static ClassFactoryImpl factory = { { &ClassFactoryImpl_Vtbl }, 0 };
 230
 231 static void ole_server(void)
 232 {
 233     HRESULT hr;
 234     DWORD key;
 235
 236     trace("server: starting %u\n", GetCurrentProcessId());
 237
 238     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 239     if (hr == S_OK)
 240     {
 241         trace("server: registering class object\n");
 242         hr = CoRegisterClassObject(&CLSID_WineTestObject, (IUnknown *)&factory,
 243                                    CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &key);
 244         if (hr == S_OK)
 245         {
 246             HANDLE done_event, init_done_event;
 247
 248             done_event = OpenEventA(SYNCHRONIZE, FALSE, "ole_server_done_event");
 249             ok(done_event != 0, "server: OpenEvent error %d\n", GetLastError());
 250             init_done_event = OpenEventA(EVENT_MODIFY_STATE, FALSE, "ole_server_init_done_event");
 251             ok(init_done_event != 0, "server: OpenEvent error %d\n", GetLastError());
 252
 253             SetEvent(init_done_event);
 254
 255             trace("server: waiting for requests\n");
 256             WaitForSingleObject(done_event, INFINITE);
 257
 258             /* 1 remainining class ref is supposed to be cleared by CoRevokeClassObject */
 259             ok(class_ref == 1, "expected 1 class refs, got %d\n", class_ref);
 260             ok(!obj_ref, "expected 0 object refs, got %d\n", obj_ref);
 261             ok(!server_locks, "expected 0 server locks, got %d\n", server_locks);
 262
 263             CloseHandle(done_event);
 264             CloseHandle(init_done_event);
 265             if (0)
 266             {
 267                 /* calling CoRevokeClassObject terminates process under Win7 */
 268                 trace("call CoRevokeClassObject\n");
 269                 CoRevokeClassObject(key);
 270                 trace("ret CoRevokeClassObject\n");
 271             }
 272         }
 273         trace("server: call CoUninitialize\n");
 274         CoUninitialize();
 275         trace("server: ret CoUninitialize\n");
 276     }
 277
 278     trace("server: exiting %u\n", GetCurrentProcessId());
 279 }
 280
 281 /******************************* OLE client *******************************/
 282 static BOOL register_server(const char *server, BOOL inproc_handler)
 283 {
 284     static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
 285     DWORD ret;
 286     HKEY root;
 287     WCHAR buf[39 + 6];
 288     char server_path[MAX_PATH];
 289
 290     lstrcpyA(server_path, server);
 291     lstrcatA(server_path, " ole_server");
 292
 293     lstrcpyW(buf, clsidW);
 294     StringFromGUID2(&CLSID_WineTestObject, buf + 6, 39);
 295
 296     ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
 297                           KEY_READ | KEY_WRITE | KEY_CREATE_SUB_KEY, NULL, &root, NULL);
 298     if (ret == ERROR_SUCCESS)
 299     {
 300         ret = RegSetValueA(root, "LocalServer32", REG_SZ, server_path, strlen(server_path));
 301         ok(ret == ERROR_SUCCESS, "RegSetValue error %u\n", ret);
 302
 303         if (inproc_handler)
 304         {
 305             ret = RegSetValueA(root, "InprocHandler32", REG_SZ, "ole32.dll", 9);
 306             ok(ret == ERROR_SUCCESS, "RegSetValue error %u\n", ret);
 307         }
 308
 309         RegCloseKey(root);
 310     }
 311
 312     return ret == ERROR_SUCCESS;
 313 }
 314
 315 static void unregister_server(void)
 316 {
 317     static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0};
 318     DWORD ret;
 319     HKEY root;
 320     WCHAR buf[39 + 6];
 321
 322     lstrcpyW(buf, clsidW);
 323     StringFromGUID2(&CLSID_WineTestObject, buf + 6, 39);
 324
 325     ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, buf, 0, NULL, 0,
 326                           DELETE, NULL, &root, NULL);
 327     if (ret == ERROR_SUCCESS)
 328     {
 329         ret = RegDeleteKeyA(root, "InprocHandler32");
 330         ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
 331         ret = RegDeleteKeyA(root, "LocalServer32");
 332         ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
 333         ret = RegDeleteKeyA(root, "");
 334         ok(ret == ERROR_SUCCESS, "RegDeleteKey error %u\n", ret);
 335         RegCloseKey(root);
 336     }
 337 }
 338
 339 static HANDLE start_server(const char *argv0)
 340 {
 341     PROCESS_INFORMATION pi;
 342     STARTUPINFOA si;
 343     SECURITY_ATTRIBUTES sa;
 344     char cmdline[MAX_PATH * 2];
 345     BOOL ret;
 346
 347     memset(&si, 0, sizeof(si));
 348     si.cb = sizeof(si);
 349     si.dwFlags = STARTF_USESTDHANDLES;
 350     si.hStdInput =  GetStdHandle(STD_INPUT_HANDLE);
 351     si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
 352     si.hStdError = si.hStdOutput;
 353
 354     sa.nLength = sizeof(sa);
 355     sa.lpSecurityDescriptor = NULL;
 356     sa.bInheritHandle = TRUE;
 357
 358     sprintf(cmdline, "\"%s\" ole_server -server", argv0);
 359     ret = CreateProcessA(argv0, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
 360     ok(ret, "CreateProcess(%s) error %d\n", cmdline, GetLastError());
 361     if (!ret) return 0;
 362
 363     CloseHandle(pi.hThread);
 364     return pi.hProcess;
 365 }
 366
 367 START_TEST(ole_server)
 368 {
 369     CLSID clsid = CLSID_WineTestObject;
 370     HRESULT hr;
 371     IClassFactory *factory;
 372     IUnknown *unknown;
 373     IOleObject *oleobj;
 374     IRunnableObject *runobj;
 375     DWORD ret;
 376     HANDLE mapping, done_event, init_done_event, process;
 377     struct winetest_info *info;
 378     int argc;
 379     char **argv;
 380
 381     mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_ole_server");
 382     ok(mapping != 0, "CreateFileMapping failed\n");
 383     info = MapViewOfFile(mapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 4096);
 384
 385     argc = winetest_get_mainargs(&argv);
 386
 387     done_event = CreateEventA(NULL, TRUE, FALSE, "ole_server_done_event");
 388     ok(done_event != 0, "CreateEvent error %d\n", GetLastError());
 389     init_done_event = CreateEventA(NULL, TRUE, FALSE, "ole_server_init_done_event");
 390     ok(init_done_event != 0, "CreateEvent error %d\n", GetLastError());
 391
 392     if (argc > 2)
 393     {
 394         if (!lstrcmpiA(argv[2], "-Embedding"))
 395         {
 396             trace("server: Refusing to be run by ole32\n");
 397             return;
 398         }
 399
 400         if (!lstrcmpiA(argv[2], "-server"))
 401         {
 402             info->child_failures = 0;
 403             ole_server();
 404             info->child_failures = winetest_get_failures();
 405             return;
 406         }
 407
 408         trace("server: Unknown parameter: %s\n", argv[2]);
 409         return;
 410     }
 411
 412     if (!register_server(argv[0], FALSE))
 413     {
 414         win_skip("not enough permissions to create a server CLSID key\n");
 415         return;
 416     }
 417
 418     if (!(process = start_server(argv[0])))
 419     {
 420         unregister_server();
 421         return;
 422     }
 423     WaitForSingleObject(init_done_event, 5000);
 424
 425     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 426     ok(hr == S_OK, "OleInitialize error %#x\n", hr);
 427
 428     hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&unknown);
 429     ok(hr == REGDB_E_CLASSNOTREG, "expected REGDB_E_CLASSNOTREG, got %#x\n", hr);
 430
 431     if (!register_server(argv[0], TRUE))
 432     {
 433         win_skip("not enough permissions to create a server CLSID key\n");
 434         unregister_server();
 435         return;
 436     }
 437
 438     trace("call CoCreateInstance(&IID_NULL)\n");
 439     hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_NULL, (void **)&unknown);
 440     trace("ret CoCreateInstance(&IID_NULL)\n");
 441     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
 442
 443     /* in-process handler supports IID_IUnknown starting from Vista */
 444     trace("call CoCreateInstance(&IID_IUnknown)\n");
 445     hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&unknown);
 446     trace("ret CoCreateInstance(&IID_IUnknown)\n");
 447     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG) /* XP,win2000 and earlier */, "CoCreateInstance(IID_IUnknown) error %#x\n", hr);
 448     if (hr != S_OK)
 449     {
 450         win_skip("In-process handler doesn't support IID_IUnknown on this platform\n");
 451         goto test_local_server;
 452     }
 453
 454     trace("call CoCreateInstance(&IID_IOleObject)\n");
 455     hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_IOleObject, (void **)&oleobj);
 456     trace("ret CoCreateInstance(&IID_IOleObject)\n");
 457     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
 458
 459     trace("call IUnknown_QueryInterface(&IID_IRunnableObject)\n");
 460     hr = IUnknown_QueryInterface(unknown, &IID_IRunnableObject, (void **)&runobj);
 461     trace("ret IUnknown_QueryInterface(&IID_IRunnableObject)\n");
 462     ok(hr == S_OK, "QueryInterface(&IID_IRunnableObject) error %#x\n", hr);
 463
 464     ret = IRunnableObject_IsRunning(runobj);
 465     ok(!ret, "expected 0, got %d\n", ret);
 466
 467     trace("call OleRun\n");
 468     hr = OleRun(unknown);
 469     trace("ret OleRun\n");
 470 todo_wine
 471     ok(hr == S_OK, "OleRun error %#x\n", hr);
 472
 473     ret = IRunnableObject_IsRunning(runobj);
 474 todo_wine
 475     ok(ret == 1, "expected 1, got %d\n", ret);
 476
 477     trace("call IRunnableObject_Release\n");
 478     ret = IRunnableObject_Release(runobj);
 479     trace("ret IRunnableObject_Release\n");
 480     ok(ret == 1, "expected ref 1, got %u\n", ret);
 481
 482     trace("call IUnknown_QueryInterface(&IID_IOleObject)\n");
 483     hr = IUnknown_QueryInterface(unknown, &IID_IOleObject, (void **)&oleobj);
 484     trace("ret IUnknown_QueryInterface(&IID_IOleObject)\n");
 485     ok(hr == S_OK, "QueryInterface(&IID_IOleObject) error %#x\n", hr);
 486
 487     trace("call IOleObject_Release\n");
 488     ret = IOleObject_Release(oleobj);
 489     trace("ret IOleObject_Release\n");
 490     ok(ret == 1, "expected ref 1, got %u\n", ret);
 491
 492     trace("call IUnknown_Release\n");
 493     ret = IUnknown_Release(unknown);
 494     trace("ret IUnknown_Release\n");
 495     ok(!ret, "expected ref 0, got %u\n", ret);
 496
 497 test_local_server:
 498     /* local server supports IID_IUnknown */
 499     trace("call CoCreateInstance(&IID_IUnknown)\n");
 500     hr = CoCreateInstance(&clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_IUnknown, (void **)&unknown);
 501     trace("ret CoCreateInstance(&IID_IUnknown)\n");
 502     ok(hr == S_OK, "CoCreateInstance(IID_IUnknown) error %#x\n", hr);
 503
 504     trace("call IUnknown_QueryInterface(&IID_IRunnableObject)\n");
 505     hr = IUnknown_QueryInterface(unknown, &IID_IRunnableObject, (void **)&runobj);
 506     trace("ret IUnknown_QueryInterface(&IID_IRunnableObject)\n");
 507     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
 508
 509     trace("call OleRun\n");
 510     hr = OleRun(unknown);
 511     trace("ret OleRun\n");
 512     ok(hr == S_OK, "OleRun error %#x\n", hr);
 513
 514     trace("call IUnknown_QueryInterface(&IID_IOleObject)\n");
 515     hr = IUnknown_QueryInterface(unknown, &IID_IOleObject, (void **)&oleobj);
 516     trace("ret IUnknown_QueryInterface(&IID_IOleObject)\n");
 517     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
 518
 519     trace("call IUnknown_Release\n");
 520     ret = IUnknown_Release(unknown);
 521     trace("ret IUnknown_Release\n");
 522     ok(!ret, "expected ref 0, got %u\n", ret);
 523
 524     trace("call CoGetClassObject(&IID_IClassFactory)\n");
 525     hr = CoGetClassObject(&clsid, CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void **)&factory);
 526     trace("ret CoGetClassObject(&IID_IClassFactory)\n");
 527     ok(hr == S_OK, "CoGetClassObject error %#x\n", hr);
 528
 529     trace("call IClassFactory_CreateInstance(&IID_NULL)\n");
 530     hr = IClassFactory_CreateInstance(factory, NULL, &IID_NULL, (void **)&oleobj);
 531     trace("ret IClassFactory_CreateInstance(&IID_NULL)\n");
 532     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
 533
 534     trace("call IClassFactory_CreateInstance(&IID_IOleObject)\n");
 535     hr = IClassFactory_CreateInstance(factory, NULL, &IID_IOleObject, (void **)&oleobj);
 536     trace("ret IClassFactory_CreateInstance(&IID_IOleObject)\n");
 537     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
 538
 539     trace("call IClassFactory_Release\n");
 540     ret = IClassFactory_Release(factory);
 541     trace("ret IClassFactory_Release\n");
 542     ok(!ret, "expected ref 0, got %u\n", ret);
 543
 544     trace("signalling termination\n");
 545     SetEvent(done_event);
 546     ret = WaitForSingleObject(process, 10000);
 547     ok(ret == WAIT_OBJECT_0, "server failed to terminate\n");
 548
 549     OleUninitialize();
 550
 551     unregister_server();
 552
 553     if (info->child_failures)
 554     {
 555         trace("%d failures in child process\n", info->child_failures);
 556         winetest_add_failures(info->child_failures);
 557     }
 558 }