developer/VSSDK/VisualStudioIntegration/Common/Source/CPP/VSL/MockInterfaces/VSLMockIOleComponentManager.h

   1 /***************************************************************************
   2
   3 Copyright (c) Microsoft Corporation. All rights reserved.
   4 This code is licensed under the Visual Studio SDK license terms.
   5 THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
   6 ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
   7 IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
   8 PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
   9
  10 This code is a part of the Visual Studio Library.
  11
  12 ***************************************************************************/
  13
  14 #ifndef IOLECOMPONENTMANAGER_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
  15 #define IOLECOMPONENTMANAGER_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
  16
  17 #if _MSC_VER > 1000
  18 #pragma once
  19 #endif
  20
  21 #include "olecm.h"
  22
  23 #pragma warning(push)
  24 #pragma warning(disable : 4510) // default constructor could not be generated
  25 #pragma warning(disable : 4610) // can never be instantiated - user defined constructor required
  26 #pragma warning(disable : 4512) // assignment operator could not be generated
  27 #pragma warning(disable : 6011) // Dereferencing NULL pointer (a NULL derference is just another kind of failure for a unit test
  28
  29 namespace VSL
  30 {
  31
  32 class IOleComponentManagerNotImpl :
  33         public IOleComponentManager
  34 {
  35
  36 VSL_DECLARE_NONINSTANTIABLE_BASE_CLASS(IOleComponentManagerNotImpl)
  37
  38 public:
  39
  40         typedef IOleComponentManager Interface;
  41
  42         STDMETHOD(QueryService)(
  43                 /*[in]*/ REFGUID /*guidService*/,
  44                 /*[in]*/ REFIID /*iid*/,
  45                 /*[out]*/ void** /*ppvObj*/)VSL_STDMETHOD_NOTIMPL
  46
  47         virtual BOOL STDMETHODCALLTYPE FReserved1(
  48                 /*[in]*/ DWORD /*dwReserved*/,
  49                 /*[in]*/ UINT /*message*/,
  50                 /*[in]*/ WPARAM /*wParam*/,
  51                 /*[in]*/ LPARAM /*lParam*/){ return BOOL(); }
  52
  53         virtual BOOL STDMETHODCALLTYPE FRegisterComponent(
  54                 /*[in]*/ IOleComponent* /*piComponent*/,
  55                 /*[in]*/ const OLECRINFO* /*pcrinfo*/,
  56                 /*[out]*/ DWORD_PTR* /*pdwComponentID*/){ return BOOL(); }
  57
  58         virtual BOOL STDMETHODCALLTYPE FRevokeComponent(
  59                 /*[in]*/ DWORD_PTR /*dwComponentID*/){ return BOOL(); }
  60
  61         virtual BOOL STDMETHODCALLTYPE FUpdateComponentRegistration(
  62                 /*[in]*/ DWORD_PTR /*dwComponentID*/,
  63                 /*[in]*/ const OLECRINFO* /*pcrinfo*/){ return BOOL(); }
  64
  65         virtual BOOL STDMETHODCALLTYPE FOnComponentActivate(
  66                 /*[in]*/ DWORD_PTR /*dwComponentID*/){ return BOOL(); }
  67
  68         virtual BOOL STDMETHODCALLTYPE FSetTrackingComponent(
  69                 /*[in]*/ DWORD_PTR /*dwComponentID*/,
  70                 /*[in]*/ BOOL /*fTrack*/){ return BOOL(); }
  71
  72         virtual void STDMETHODCALLTYPE OnComponentEnterState(
  73                 /*[in]*/ DWORD_PTR /*dwComponentID*/,
  74                 /*[in]*/ OLECSTATE /*uStateID*/,
  75                 /*[in]*/ OLECCONTEXT /*uContext*/,
  76                 /*[in]*/ ULONG /*cpicmExclude*/,
  77                 /*[in]*/ IOleComponentManager** /*rgpicmExclude*/,
  78                 /*[in]*/ DWORD /*dwReserved*/){ return ; }
  79
  80         virtual BOOL STDMETHODCALLTYPE FOnComponentExitState(
  81                 /*[in]*/ DWORD_PTR /*dwComponentID*/,
  82                 /*[in]*/ OLECSTATE /*uStateID*/,
  83                 /*[in]*/ OLECCONTEXT /*uContext*/,
  84                 /*[in]*/ ULONG /*cpicmExclude*/,
  85                 /*[in]*/ IOleComponentManager** /*rgpicmExclude*/){ return BOOL(); }
  86
  87         virtual BOOL STDMETHODCALLTYPE FInState(
  88                 /*[in]*/ OLECSTATE /*uStateID*/,
  89                 /*[in]*/ void* /*pvoid*/){ return BOOL(); }
  90
  91         virtual BOOL STDMETHODCALLTYPE FContinueIdle(){ return BOOL(); }
  92
  93         virtual BOOL STDMETHODCALLTYPE FPushMessageLoop(
  94                 /*[in]*/ DWORD_PTR /*dwComponentID*/,
  95                 /*[in]*/ OLELOOP /*uReason*/,
  96                 /*[in]*/ void* /*pvLoopData*/){ return BOOL(); }
  97
  98         virtual BOOL STDMETHODCALLTYPE FCreateSubComponentManager(
  99                 /*[in]*/ IUnknown* /*piunkOuter*/,
 100                 /*[in]*/ IUnknown* /*piunkServProv*/,
 101                 /*[in]*/ REFIID /*riid*/,
 102                 /*[out]*/ void** /*ppvObj*/){ return BOOL(); }
 103
 104         virtual BOOL STDMETHODCALLTYPE FGetParentComponentManager(
 105                 /*[out]*/ IOleComponentManager** /*ppicm*/){ return BOOL(); }
 106
 107         virtual BOOL STDMETHODCALLTYPE FGetActiveComponent(
 108                 /*[in]*/ OLEGAC /*dwgac*/,
 109                 /*[out]*/ IOleComponent** /*ppic*/,
 110                 /*[in,out]*/ OLECRINFO* /*pcrinfo*/,
 111                 /*[in]*/ DWORD /*dwReserved*/){ return BOOL(); }
 112 };
 113
 114 class IOleComponentManagerMockImpl :
 115         public IOleComponentManager,
 116         public MockBase
 117 {
 118
 119 VSL_DECLARE_NONINSTANTIABLE_BASE_CLASS(IOleComponentManagerMockImpl)
 120
 121 public:
 122
 123 VSL_DEFINE_MOCK_CLASS_TYPDEFS(IOleComponentManagerMockImpl)
 124
 125         typedef IOleComponentManager Interface;
 126         struct QueryServiceValidValues
 127         {
 128                 /*[in]*/ REFGUID guidService;
 129                 /*[in]*/ REFIID iid;
 130                 /*[out]*/ void** ppvObj;
 131                 HRESULT retValue;
 132         };
 133
 134         STDMETHOD(QueryService)(
 135                 /*[in]*/ REFGUID guidService,
 136                 /*[in]*/ REFIID iid,
 137                 /*[out]*/ void** ppvObj)
 138         {
 139                 VSL_DEFINE_MOCK_METHOD(QueryService)
 140
 141                 VSL_CHECK_VALIDVALUE(guidService);
 142
 143                 VSL_CHECK_VALIDVALUE(iid);
 144
 145                 VSL_SET_VALIDVALUE(ppvObj);
 146
 147                 VSL_RETURN_VALIDVALUES();
 148         }
 149         struct FReserved1ValidValues
 150         {
 151                 /*[in]*/ DWORD dwReserved;
 152                 /*[in]*/ UINT message;
 153                 /*[in]*/ WPARAM wParam;
 154                 /*[in]*/ LPARAM lParam;
 155                 BOOL retValue;
 156         };
 157
 158         virtual BOOL _stdcall FReserved1(
 159                 /*[in]*/ DWORD dwReserved,
 160                 /*[in]*/ UINT message,
 161                 /*[in]*/ WPARAM wParam,
 162                 /*[in]*/ LPARAM lParam)
 163         {
 164                 VSL_DEFINE_MOCK_METHOD(FReserved1)
 165
 166                 VSL_CHECK_VALIDVALUE(dwReserved);
 167
 168                 VSL_CHECK_VALIDVALUE(message);
 169
 170                 VSL_CHECK_VALIDVALUE(wParam);
 171
 172                 VSL_CHECK_VALIDVALUE(lParam);
 173
 174                 VSL_RETURN_VALIDVALUES();
 175         }
 176         struct FRegisterComponentValidValues
 177         {
 178                 /*[in]*/ IOleComponent* piComponent;
 179                 /*[in]*/ OLECRINFO* pcrinfo;
 180                 /*[out]*/ DWORD_PTR* pdwComponentID;
 181                 BOOL retValue;
 182         };
 183
 184         virtual BOOL _stdcall FRegisterComponent(
 185                 /*[in]*/ IOleComponent* piComponent,
 186                 /*[in]*/ const OLECRINFO* pcrinfo,
 187                 /*[out]*/ DWORD_PTR* pdwComponentID)
 188         {
 189                 VSL_DEFINE_MOCK_METHOD(FRegisterComponent)
 190
 191                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(piComponent);
 192
 193                 VSL_CHECK_VALIDVALUE_POINTER(pcrinfo);
 194
 195                 VSL_SET_VALIDVALUE(pdwComponentID);
 196
 197                 VSL_RETURN_VALIDVALUES();
 198         }
 199         struct FRevokeComponentValidValues
 200         {
 201                 /*[in]*/ DWORD_PTR dwComponentID;
 202                 BOOL retValue;
 203         };
 204
 205         virtual BOOL _stdcall FRevokeComponent(
 206                 /*[in]*/ DWORD_PTR dwComponentID)
 207         {
 208                 VSL_DEFINE_MOCK_METHOD(FRevokeComponent)
 209
 210                 VSL_CHECK_VALIDVALUE(dwComponentID);
 211
 212                 VSL_RETURN_VALIDVALUES();
 213         }
 214         struct FUpdateComponentRegistrationValidValues
 215         {
 216                 /*[in]*/ DWORD_PTR dwComponentID;
 217                 /*[in]*/ OLECRINFO* pcrinfo;
 218                 BOOL retValue;
 219         };
 220
 221         virtual BOOL _stdcall FUpdateComponentRegistration(
 222                 /*[in]*/ DWORD_PTR dwComponentID,
 223                 /*[in]*/ const OLECRINFO* pcrinfo)
 224         {
 225                 VSL_DEFINE_MOCK_METHOD(FUpdateComponentRegistration)
 226
 227                 VSL_CHECK_VALIDVALUE(dwComponentID);
 228
 229                 VSL_CHECK_VALIDVALUE_POINTER(pcrinfo);
 230
 231                 VSL_RETURN_VALIDVALUES();
 232         }
 233         struct FOnComponentActivateValidValues
 234         {
 235                 /*[in]*/ DWORD_PTR dwComponentID;
 236                 BOOL retValue;
 237         };
 238
 239         virtual BOOL _stdcall FOnComponentActivate(
 240                 /*[in]*/ DWORD_PTR dwComponentID)
 241         {
 242                 VSL_DEFINE_MOCK_METHOD(FOnComponentActivate)
 243
 244                 VSL_CHECK_VALIDVALUE(dwComponentID);
 245
 246                 VSL_RETURN_VALIDVALUES();
 247         }
 248         struct FSetTrackingComponentValidValues
 249         {
 250                 /*[in]*/ DWORD_PTR dwComponentID;
 251                 /*[in]*/ BOOL fTrack;
 252                 BOOL retValue;
 253         };
 254
 255         virtual BOOL _stdcall FSetTrackingComponent(
 256                 /*[in]*/ DWORD_PTR dwComponentID,
 257                 /*[in]*/ BOOL fTrack)
 258         {
 259                 VSL_DEFINE_MOCK_METHOD(FSetTrackingComponent)
 260
 261                 VSL_CHECK_VALIDVALUE(dwComponentID);
 262
 263                 VSL_CHECK_VALIDVALUE(fTrack);
 264
 265                 VSL_RETURN_VALIDVALUES();
 266         }
 267         struct OnComponentEnterStateValidValues
 268         {
 269                 /*[in]*/ DWORD_PTR dwComponentID;
 270                 /*[in]*/ OLECSTATE uStateID;
 271                 /*[in]*/ OLECCONTEXT uContext;
 272                 /*[in]*/ ULONG cpicmExclude;
 273                 /*[in]*/ IOleComponentManager** rgpicmExclude;
 274                 /*[in]*/ DWORD dwReserved;
 275         };
 276
 277         virtual void _stdcall OnComponentEnterState(
 278                 /*[in]*/ DWORD_PTR dwComponentID,
 279                 /*[in]*/ OLECSTATE uStateID,
 280                 /*[in]*/ OLECCONTEXT uContext,
 281                 /*[in]*/ ULONG cpicmExclude,
 282                 /*[in]*/ IOleComponentManager** rgpicmExclude,
 283                 /*[in]*/ DWORD dwReserved)
 284         {
 285                 VSL_DEFINE_MOCK_METHOD(OnComponentEnterState)
 286
 287                 VSL_CHECK_VALIDVALUE(dwComponentID);
 288
 289                 VSL_CHECK_VALIDVALUE(uStateID);
 290
 291                 VSL_CHECK_VALIDVALUE(uContext);
 292
 293                 VSL_CHECK_VALIDVALUE(cpicmExclude);
 294
 295                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(rgpicmExclude);
 296
 297                 VSL_CHECK_VALIDVALUE(dwReserved);
 298
 299         }
 300         struct FOnComponentExitStateValidValues
 301         {
 302                 /*[in]*/ DWORD_PTR dwComponentID;
 303                 /*[in]*/ OLECSTATE uStateID;
 304                 /*[in]*/ OLECCONTEXT uContext;
 305                 /*[in]*/ ULONG cpicmExclude;
 306                 /*[in]*/ IOleComponentManager** rgpicmExclude;
 307                 BOOL retValue;
 308         };
 309
 310         virtual BOOL _stdcall FOnComponentExitState(
 311                 /*[in]*/ DWORD_PTR dwComponentID,
 312                 /*[in]*/ OLECSTATE uStateID,
 313                 /*[in]*/ OLECCONTEXT uContext,
 314                 /*[in]*/ ULONG cpicmExclude,
 315                 /*[in]*/ IOleComponentManager** rgpicmExclude)
 316         {
 317                 VSL_DEFINE_MOCK_METHOD(FOnComponentExitState)
 318
 319                 VSL_CHECK_VALIDVALUE(dwComponentID);
 320
 321                 VSL_CHECK_VALIDVALUE(uStateID);
 322
 323                 VSL_CHECK_VALIDVALUE(uContext);
 324
 325                 VSL_CHECK_VALIDVALUE(cpicmExclude);
 326
 327                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(rgpicmExclude);
 328
 329                 VSL_RETURN_VALIDVALUES();
 330         }
 331         struct FInStateValidValues
 332         {
 333                 /*[in]*/ OLECSTATE uStateID;
 334                 /*[in]*/ void* pvoid;
 335                 BOOL retValue;
 336                 size_t pvoid_size_in_bytes;
 337         };
 338
 339         virtual BOOL _stdcall FInState(
 340                 /*[in]*/ OLECSTATE uStateID,
 341                 /*[in]*/ void* pvoid)
 342         {
 343                 VSL_DEFINE_MOCK_METHOD(FInState)
 344
 345                 VSL_CHECK_VALIDVALUE(uStateID);
 346
 347                 VSL_CHECK_VALIDVALUE_PVOID(pvoid);
 348
 349                 VSL_RETURN_VALIDVALUES();
 350         }
 351         struct FContinueIdleValidValues
 352         {
 353                 BOOL retValue;
 354         };
 355
 356         virtual BOOL _stdcall FContinueIdle()
 357         {
 358                 VSL_DEFINE_MOCK_METHOD_NOARGS(FContinueIdle)
 359
 360                 VSL_RETURN_VALIDVALUES();
 361         }
 362         struct FPushMessageLoopValidValues
 363         {
 364                 /*[in]*/ DWORD_PTR dwComponentID;
 365                 /*[in]*/ OLELOOP uReason;
 366                 /*[in]*/ void* pvLoopData;
 367                 BOOL retValue;
 368                 size_t pvLoopData_size_in_bytes;
 369         };
 370
 371         virtual BOOL _stdcall FPushMessageLoop(
 372                 /*[in]*/ DWORD_PTR dwComponentID,
 373                 /*[in]*/ OLELOOP uReason,
 374                 /*[in]*/ void* pvLoopData)
 375         {
 376                 VSL_DEFINE_MOCK_METHOD(FPushMessageLoop)
 377
 378                 VSL_CHECK_VALIDVALUE(dwComponentID);
 379
 380                 VSL_CHECK_VALIDVALUE(uReason);
 381
 382                 VSL_CHECK_VALIDVALUE_PVOID(pvLoopData);
 383
 384                 VSL_RETURN_VALIDVALUES();
 385         }
 386         struct FCreateSubComponentManagerValidValues
 387         {
 388                 /*[in]*/ IUnknown* piunkOuter;
 389                 /*[in]*/ IUnknown* piunkServProv;
 390                 /*[in]*/ REFIID riid;
 391                 /*[out]*/ void** ppvObj;
 392                 BOOL retValue;
 393         };
 394
 395         virtual BOOL _stdcall FCreateSubComponentManager(
 396                 /*[in]*/ IUnknown* piunkOuter,
 397                 /*[in]*/ IUnknown* piunkServProv,
 398                 /*[in]*/ REFIID riid,
 399                 /*[out]*/ void** ppvObj)
 400         {
 401                 VSL_DEFINE_MOCK_METHOD(FCreateSubComponentManager)
 402
 403                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(piunkOuter);
 404
 405                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(piunkServProv);
 406
 407                 VSL_CHECK_VALIDVALUE(riid);
 408
 409                 VSL_SET_VALIDVALUE(ppvObj);
 410
 411                 VSL_RETURN_VALIDVALUES();
 412         }
 413         struct FGetParentComponentManagerValidValues
 414         {
 415                 /*[out]*/ IOleComponentManager** ppicm;
 416                 BOOL retValue;
 417         };
 418
 419         virtual BOOL _stdcall FGetParentComponentManager(
 420                 /*[out]*/ IOleComponentManager** ppicm)
 421         {
 422                 VSL_DEFINE_MOCK_METHOD(FGetParentComponentManager)
 423
 424                 VSL_SET_VALIDVALUE_INTERFACE(ppicm);
 425
 426                 VSL_RETURN_VALIDVALUES();
 427         }
 428         struct FGetActiveComponentValidValues
 429         {
 430                 /*[in]*/ OLEGAC dwgac;
 431                 /*[out]*/ IOleComponent** ppic;
 432                 /*[in,out]*/ OLECRINFO* pcrinfo;
 433                 /*[in]*/ DWORD dwReserved;
 434                 BOOL retValue;
 435         };
 436
 437         virtual BOOL _stdcall FGetActiveComponent(
 438                 /*[in]*/ OLEGAC dwgac,
 439                 /*[out]*/ IOleComponent** ppic,
 440                 /*[in,out]*/ OLECRINFO* pcrinfo,
 441                 /*[in]*/ DWORD dwReserved)
 442         {
 443                 VSL_DEFINE_MOCK_METHOD(FGetActiveComponent)
 444
 445                 VSL_CHECK_VALIDVALUE(dwgac);
 446
 447                 VSL_SET_VALIDVALUE_INTERFACE(ppic);
 448
 449                 VSL_SET_VALIDVALUE(pcrinfo);
 450
 451                 VSL_CHECK_VALIDVALUE(dwReserved);
 452
 453                 VSL_RETURN_VALIDVALUES();
 454         }
 455 };
 456
 457
 458 } // namespace VSL
 459
 460 #pragma warning(pop)
 461
 462 #endif // IOLECOMPONENTMANAGER_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5