git.oblomov.eu Git - wine/blob - dlls/mscoree/tests/debugging.c

   1 /*
   2  * Copyright 2011 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #include <stdio.h>
  21
  22 #include "windows.h"
  23 #include "ole2.h"
  24 #include "corerror.h"
  25 #include "mscoree.h"
  26 #include "corhdr.h"
  27
  28 #include "wine/test.h"
  29
  30 #include "initguid.h"
  31 #include "cordebug.h"
  32
  33 static HMODULE hmscoree;
  34
  35 static HRESULT (WINAPI *pCreateDebuggingInterfaceFromVersion)(int, LPCWSTR, IUnknown **);
  36
  37 const WCHAR v2_0[] = {'v','2','.','0','.','5','0','7','2','7',0};
  38
  39 static const char *debugstr_guid(REFIID riid)
  40 {
  41     static char buf[50];
  42
  43     if(!riid)
  44         return "(null)";
  45
  46     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  47             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  48             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  49             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  50
  51     return buf;
  52 }
  53
  54 static HRESULT WINAPI ManagedCallback2_QueryInterface(ICorDebugManagedCallback2 *iface, REFIID riid, void **ppv)
  55 {
  56     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_ICorDebugManagedCallback2, riid))
  57     {
  58         *ppv = iface;
  59         return S_OK;
  60     }
  61
  62     ok(0, "unexpected riid (%s)\n", debugstr_guid(riid));
  63
  64     *ppv = NULL;
  65     return E_NOINTERFACE;
  66 }
  67
  68 static ULONG WINAPI ManagedCallback2_AddRef(ICorDebugManagedCallback2 *iface)
  69 {
  70     return 2;
  71 }
  72
  73 static ULONG WINAPI ManagedCallback2_Release(ICorDebugManagedCallback2 *iface)
  74 {
  75     return 1;
  76 }
  77
  78 static HRESULT WINAPI ManagedCallback2_FunctionRemapOpportunity(ICorDebugManagedCallback2 *iface,
  79                 ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread,
  80                 ICorDebugFunction *pOldFunction, ICorDebugFunction *pNewFunction,
  81                 ULONG32 oldILOffset)
  82 {
  83     ok(0, "unexpected call\n");
  84     return E_NOTIMPL;
  85 }
  86
  87 static HRESULT WINAPI ManagedCallback2_CreateConnection(ICorDebugManagedCallback2 *iface,
  88                 ICorDebugProcess *pProcess, CONNID dwConnectionId, WCHAR *pConnName)
  89 {
  90     ok(0, "unexpected call\n");
  91     return E_NOTIMPL;
  92 }
  93
  94 static HRESULT WINAPI ManagedCallback2_ChangeConnection(ICorDebugManagedCallback2 *iface,
  95                 ICorDebugProcess *pProcess, CONNID dwConnectionId)
  96 {
  97     ok(0, "unexpected call\n");
  98     return E_NOTIMPL;
  99 }
 100
 101 static HRESULT WINAPI ManagedCallback2_DestroyConnection(ICorDebugManagedCallback2 *iface,
 102                 ICorDebugProcess *pProcess, CONNID dwConnectionId)
 103 {
 104     ok(0, "unexpected call\n");
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI ManagedCallback2_Exception(ICorDebugManagedCallback2 *iface,
 109                 ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread,
 110                 ICorDebugFrame *pFrame, ULONG32 nOffset,
 111                 CorDebugExceptionCallbackType dwEventType, DWORD dwFlags)
 112 {
 113     ok(0, "unexpected call\n");
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI ManagedCallback2_ExceptionUnwind(ICorDebugManagedCallback2 *iface,
 118                 ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread,
 119                 CorDebugExceptionUnwindCallbackType dwEventType, DWORD dwFlags)
 120 {
 121     ok(0, "unexpected call\n");
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI ManagedCallback2_FunctionRemapComplete(ICorDebugManagedCallback2 *iface,
 126                 ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread,
 127                 ICorDebugFunction *pFunction)
 128 {
 129     ok(0, "unexpected call\n");
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI ManagedCallback2_MDANotification(ICorDebugManagedCallback2 *iface,
 134                 ICorDebugController *pController, ICorDebugThread *pThread,
 135                 ICorDebugMDA *pMDA)
 136 {
 137     ok(0, "unexpected call\n");
 138     return E_NOTIMPL;
 139 }
 140
 141 static struct ICorDebugManagedCallback2Vtbl managedCallback2Vtbl = {
 142     ManagedCallback2_QueryInterface,
 143     ManagedCallback2_AddRef,
 144     ManagedCallback2_Release,
 145     ManagedCallback2_FunctionRemapOpportunity,
 146     ManagedCallback2_CreateConnection,
 147     ManagedCallback2_ChangeConnection,
 148     ManagedCallback2_DestroyConnection,
 149     ManagedCallback2_Exception,
 150     ManagedCallback2_ExceptionUnwind,
 151     ManagedCallback2_FunctionRemapComplete,
 152     ManagedCallback2_MDANotification
 153 };
 154
 155 static ICorDebugManagedCallback2 ManagedCallback2 = { &managedCallback2Vtbl };
 156
 157 static HRESULT WINAPI ManagedCallback_QueryInterface(ICorDebugManagedCallback *iface, REFIID riid, void **ppv)
 158 {
 159     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_ICorDebugManagedCallback, riid))
 160     {
 161         *ppv = iface;
 162         return S_OK;
 163     }
 164     else if(IsEqualGUID(&IID_ICorDebugManagedCallback2, riid))
 165     {
 166         *ppv = (void**)&ManagedCallback2;
 167         return S_OK;
 168     }
 169
 170     ok(0, "unexpected riid (%s)\n", debugstr_guid(riid));
 171     *ppv = NULL;
 172     return E_NOINTERFACE;
 173 }
 174
 175 static ULONG WINAPI ManagedCallback_AddRef(ICorDebugManagedCallback *iface)
 176 {
 177     return 2;
 178 }
 179
 180 static ULONG WINAPI ManagedCallback_Release(ICorDebugManagedCallback *iface)
 181 {
 182     return 1;
 183 }
 184
 185 static HRESULT WINAPI ManagedCallback_Breakpoint(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 186                     ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint)
 187 {
 188     ok(0, "unexpected call\n");
 189     return E_NOTIMPL;
 190 }
 191
 192 static HRESULT WINAPI ManagedCallback_StepComplete(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 193                     ICorDebugThread *pThread, ICorDebugStepper *pStepper, CorDebugStepReason reason)
 194 {
 195     ok(0, "unexpected call\n");
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI ManagedCallback_Break(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 200                     ICorDebugThread *thread)
 201 {
 202     ok(0, "unexpected call\n");
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI ManagedCallback_Exception(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 207                     ICorDebugThread *pThread, BOOL unhandled)
 208 {
 209     ok(0, "unexpected call\n");
 210     return E_NOTIMPL;
 211 }
 212
 213 static HRESULT WINAPI ManagedCallback_EvalComplete(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 214                     ICorDebugThread *pThread, ICorDebugEval *pEval)
 215 {
 216     ok(0, "unexpected call\n");
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI ManagedCallback_EvalException(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 221                     ICorDebugThread *pThread, ICorDebugEval *pEval)
 222 {
 223     ok(0, "unexpected call\n");
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI ManagedCallback_CreateProcess(ICorDebugManagedCallback *iface, ICorDebugProcess *pProcess)
 228 {
 229     ok(0, "unexpected call\n");
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI ManagedCallback_ExitProcess(ICorDebugManagedCallback *iface, ICorDebugProcess *pProcess)
 234 {
 235     ok(0, "unexpected call\n");
 236     return E_NOTIMPL;
 237 }
 238
 239 static HRESULT WINAPI ManagedCallback_CreateThread(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 240                     ICorDebugThread *thread)
 241 {
 242     ok(0, "unexpected call\n");
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI ManagedCallback_ExitThread(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 247                     ICorDebugThread *thread)
 248 {
 249     ok(0, "unexpected call\n");
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI ManagedCallback_LoadModule(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 254                     ICorDebugModule *pModule)
 255 {
 256     ok(0, "unexpected call\n");
 257     return E_NOTIMPL;
 258 }
 259
 260 static HRESULT WINAPI ManagedCallback_UnloadModule(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 261                     ICorDebugModule *pModule)
 262 {
 263     ok(0, "unexpected call\n");
 264     return E_NOTIMPL;
 265 }
 266
 267 static HRESULT WINAPI ManagedCallback_LoadClass(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 268                     ICorDebugClass *c)
 269 {
 270     ok(0, "unexpected call\n");
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI ManagedCallback_UnloadClass(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 275                     ICorDebugClass *c)
 276 {
 277     ok(0, "unexpected call\n");
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI ManagedCallback_DebuggerError(ICorDebugManagedCallback *iface, ICorDebugProcess *pProcess,
 282                     HRESULT errorHR, DWORD errorCode)
 283 {
 284     ok(0, "unexpected call\n");
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI ManagedCallback_LogMessage(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 289                     ICorDebugThread *pThread, LONG lLevel, WCHAR *pLogSwitchName, WCHAR *pMessage)
 290 {
 291     ok(0, "unexpected call\n");
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI ManagedCallback_LogSwitch(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 296                     ICorDebugThread *pThread, LONG lLevel, ULONG ulReason,
 297                     WCHAR *pLogSwitchName, WCHAR *pParentName)
 298 {
 299     ok(0, "unexpected call\n");
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI ManagedCallback_CreateAppDomain(ICorDebugManagedCallback *iface, ICorDebugProcess *pProcess,
 304                     ICorDebugAppDomain *pAppDomain)
 305 {
 306     ok(0, "unexpected call\n");
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI ManagedCallback_ExitAppDomain(ICorDebugManagedCallback *iface, ICorDebugProcess *pProcess,
 311                     ICorDebugAppDomain *pAppDomain)
 312 {
 313     ok(0, "unexpected call\n");
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI ManagedCallback_LoadAssembly(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 318                     ICorDebugAssembly *pAssembly)
 319 {
 320     ok(0, "unexpected call\n");
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI ManagedCallback_UnloadAssembly(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 325                     ICorDebugAssembly *pAssembly)
 326 {
 327     ok(0, "unexpected call\n");
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI ManagedCallback_ControlCTrap(ICorDebugManagedCallback *iface, ICorDebugProcess *pProcess)
 332 {
 333     ok(0, "unexpected call\n");
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI ManagedCallback_NameChange(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 338                     ICorDebugThread *pThread)
 339 {
 340     ok(0, "unexpected call\n");
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI ManagedCallback_UpdateModuleSymbols(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 345                     ICorDebugModule *pModule, IStream *pSymbolStream)
 346 {
 347     ok(0, "unexpected call\n");
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI ManagedCallback_EditAndContinueRemap(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 352                     ICorDebugThread *pThread, ICorDebugFunction *pFunction, BOOL fAccurate)
 353 {
 354     ok(0, "unexpected call\n");
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI ManagedCallback_BreakpointSetError(ICorDebugManagedCallback *iface, ICorDebugAppDomain *pAppDomain,
 359                     ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, DWORD dwError)
 360 {
 361     ok(0, "unexpected call\n");
 362     return E_NOTIMPL;
 363 }
 364
 365 static ICorDebugManagedCallbackVtbl managedCallbackVtbl = {
 366     ManagedCallback_QueryInterface,
 367     ManagedCallback_AddRef,
 368     ManagedCallback_Release,
 369     ManagedCallback_Breakpoint,
 370     ManagedCallback_StepComplete,
 371     ManagedCallback_Break,
 372     ManagedCallback_Exception,
 373     ManagedCallback_EvalComplete,
 374     ManagedCallback_EvalException,
 375     ManagedCallback_CreateProcess,
 376     ManagedCallback_ExitProcess,
 377     ManagedCallback_CreateThread,
 378     ManagedCallback_ExitThread,
 379     ManagedCallback_LoadModule,
 380     ManagedCallback_UnloadModule,
 381     ManagedCallback_LoadClass,
 382     ManagedCallback_UnloadClass,
 383     ManagedCallback_DebuggerError,
 384     ManagedCallback_LogMessage,
 385     ManagedCallback_LogSwitch,
 386     ManagedCallback_CreateAppDomain,
 387     ManagedCallback_ExitAppDomain,
 388     ManagedCallback_LoadAssembly,
 389     ManagedCallback_UnloadAssembly,
 390     ManagedCallback_ControlCTrap,
 391     ManagedCallback_NameChange,
 392     ManagedCallback_UpdateModuleSymbols,
 393     ManagedCallback_EditAndContinueRemap,
 394     ManagedCallback_BreakpointSetError
 395 };
 396
 397 static ICorDebugManagedCallback ManagedCallback = { &managedCallbackVtbl };
 398
 399 static BOOL init_functionpointers(void)
 400 {
 401     hmscoree = LoadLibraryA("mscoree.dll");
 402
 403     if (!hmscoree)
 404     {
 405         win_skip("mscoree.dll not available\n");
 406         return FALSE;
 407     }
 408
 409     pCreateDebuggingInterfaceFromVersion = (void *)GetProcAddress(hmscoree, "CreateDebuggingInterfaceFromVersion");
 410
 411     if (!pCreateDebuggingInterfaceFromVersion)
 412     {
 413         win_skip("functions not available\n");
 414         FreeLibrary(hmscoree);
 415         return FALSE;
 416     }
 417
 418     return TRUE;
 419 }
 420
 421 #define check_process_enum(core, e) _check_process_enum(__LINE__, core, e)
 422 static void _check_process_enum(unsigned line, ICorDebug *pCorDebug, ULONG nExpected)
 423 {
 424     HRESULT hr;
 425     ICorDebugProcessEnum *pProcessEnum = NULL;
 426
 427     hr = ICorDebug_EnumerateProcesses(pCorDebug, NULL);
 428     ok_(__FILE__,line) (hr == E_INVALIDARG, "expected E_INVALIDARG got %08x\n", hr);
 429
 430     hr = ICorDebug_EnumerateProcesses(pCorDebug, &pProcessEnum);
 431     ok_(__FILE__,line) (hr == S_OK, "expected S_OK got %08x\n", hr);
 432     if(hr == S_OK)
 433     {
 434         ULONG cnt;
 435
 436         hr = ICorDebugProcessEnum_GetCount(pProcessEnum, &cnt);
 437         ok_(__FILE__,line) (hr == S_OK, "expected S_OK got %08x\n", hr);
 438         ok_(__FILE__,line) (cnt == nExpected, "expected %d got %d\n", nExpected, cnt);
 439
 440         ICorDebugProcessEnum_Release(pProcessEnum);
 441     }
 442 }
 443
 444 static void test_createDebugger(void)
 445 {
 446     HRESULT hr;
 447     IUnknown *pUnk;
 448     ICorDebug *pCorDebug;
 449
 450     hr = pCreateDebuggingInterfaceFromVersion(0, v2_0, &pUnk);
 451     ok(hr == E_INVALIDARG, "CreateDebuggingInterfaceFromVersion returned %08x\n", hr);
 452
 453     hr = pCreateDebuggingInterfaceFromVersion(1, v2_0, &pUnk);
 454     ok(hr == E_INVALIDARG, "CreateDebuggingInterfaceFromVersion returned %08x\n", hr);
 455
 456     hr = pCreateDebuggingInterfaceFromVersion(2, v2_0, &pUnk);
 457     ok(hr == E_INVALIDARG, "CreateDebuggingInterfaceFromVersion returned %08x\n", hr);
 458
 459     hr = pCreateDebuggingInterfaceFromVersion(4, v2_0, &pUnk);
 460     ok(hr == E_INVALIDARG, "CreateDebuggingInterfaceFromVersion returned %08x\n", hr);
 461
 462     hr = pCreateDebuggingInterfaceFromVersion(3, v2_0, NULL);
 463     ok(hr == E_INVALIDARG, "CreateDebuggingInterfaceFromVersion returned %08x\n", hr);
 464
 465     hr = pCreateDebuggingInterfaceFromVersion(3, v2_0, &pUnk);
 466     if(hr == S_OK)
 467     {
 468         hr = IUnknown_QueryInterface(pUnk, &IID_ICorDebug, (void**)&pCorDebug);
 469         ok(hr == S_OK, "expected S_OK got %08x\n", hr);
 470         if(hr == S_OK)
 471         {
 472             hr = ICorDebug_Initialize(pCorDebug);
 473             ok(hr == S_OK, "expected S_OK got %08x\n", hr);
 474             if(hr == S_OK)
 475             {
 476                 hr = ICorDebug_SetManagedHandler(pCorDebug, NULL);
 477                 ok(hr == E_INVALIDARG, "expected E_INVALIDARG got %08x\n", hr);
 478
 479                 hr = ICorDebug_SetManagedHandler(pCorDebug, &ManagedCallback);
 480                 ok(hr == S_OK, "expected S_OK got %08x\n", hr);
 481
 482                 /* We should have no processes */
 483                 check_process_enum(pCorDebug, 0);
 484             }
 485
 486             ICorDebug_Release(pCorDebug);
 487         }
 488         IUnknown_Release(pUnk);
 489     }
 490     else
 491     {
 492         skip(".NET 2.0 or mono not installed.\n");
 493     }
 494 }
 495
 496 START_TEST(debugging)
 497 {
 498     CoInitialize(NULL);
 499
 500     if (!init_functionpointers())
 501         return;
 502
 503     test_createDebugger();
 504
 505     FreeLibrary(hmscoree);
 506     CoUninitialize();
 507 }