developer/VSSDK/VisualStudioIntegration/Common/Source/CPP/VSL/MockInterfaces/VSLMockIXMLDOMCDATASection.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 IXMLDOMCDATASECTION_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
  15 #define IXMLDOMCDATASECTION_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5
  16
  17 #if _MSC_VER > 1000
  18 #pragma once
  19 #endif
  20
  21 #include "XmlDom.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 IXMLDOMCDATASectionNotImpl :
  33         public IXMLDOMCDATASection
  34 {
  35
  36 VSL_DECLARE_NONINSTANTIABLE_BASE_CLASS(IXMLDOMCDATASectionNotImpl)
  37
  38 public:
  39
  40         typedef IXMLDOMCDATASection Interface;
  41
  42         STDMETHOD(splitText)(
  43                 /*[in]*/ long /*offset*/,
  44                 /*[out,retval]*/ IXMLDOMText** /*rightHandTextNode*/)VSL_STDMETHOD_NOTIMPL
  45
  46         STDMETHOD(get_data)(
  47                 /*[out,retval]*/ BSTR* /*data*/)VSL_STDMETHOD_NOTIMPL
  48
  49         STDMETHOD(put_data)(
  50                 /*[in]*/ BSTR /*data*/)VSL_STDMETHOD_NOTIMPL
  51
  52         STDMETHOD(get_length)(
  53                 /*[out,retval]*/ long* /*dataLength*/)VSL_STDMETHOD_NOTIMPL
  54
  55         STDMETHOD(substringData)(
  56                 /*[in]*/ long /*offset*/,
  57                 /*[in]*/ long /*count*/,
  58                 /*[out,retval]*/ BSTR* /*data*/)VSL_STDMETHOD_NOTIMPL
  59
  60         STDMETHOD(appendData)(
  61                 /*[in]*/ BSTR /*data*/)VSL_STDMETHOD_NOTIMPL
  62
  63         STDMETHOD(insertData)(
  64                 /*[in]*/ long /*offset*/,
  65                 /*[in]*/ BSTR /*data*/)VSL_STDMETHOD_NOTIMPL
  66
  67         STDMETHOD(deleteData)(
  68                 /*[in]*/ long /*offset*/,
  69                 /*[in]*/ long /*count*/)VSL_STDMETHOD_NOTIMPL
  70
  71         STDMETHOD(replaceData)(
  72                 /*[in]*/ long /*offset*/,
  73                 /*[in]*/ long /*count*/,
  74                 /*[in]*/ BSTR /*data*/)VSL_STDMETHOD_NOTIMPL
  75
  76         STDMETHOD(get_nodeName)(
  77                 /*[out,retval]*/ BSTR* /*name*/)VSL_STDMETHOD_NOTIMPL
  78
  79         STDMETHOD(get_nodeValue)(
  80                 /*[out,retval]*/ VARIANT* /*value*/)VSL_STDMETHOD_NOTIMPL
  81
  82         STDMETHOD(put_nodeValue)(
  83                 /*[in]*/ VARIANT /*value*/)VSL_STDMETHOD_NOTIMPL
  84
  85         STDMETHOD(get_nodeType)(
  86                 /*[out,retval]*/ DOMNodeType* /*type*/)VSL_STDMETHOD_NOTIMPL
  87
  88         STDMETHOD(get_parentNode)(
  89                 /*[out,retval]*/ IXMLDOMNode** /*parent*/)VSL_STDMETHOD_NOTIMPL
  90
  91         STDMETHOD(get_childNodes)(
  92                 /*[out,retval]*/ IXMLDOMNodeList** /*childList*/)VSL_STDMETHOD_NOTIMPL
  93
  94         STDMETHOD(get_firstChild)(
  95                 /*[out,retval]*/ IXMLDOMNode** /*firstChild*/)VSL_STDMETHOD_NOTIMPL
  96
  97         STDMETHOD(get_lastChild)(
  98                 /*[out,retval]*/ IXMLDOMNode** /*lastChild*/)VSL_STDMETHOD_NOTIMPL
  99
 100         STDMETHOD(get_previousSibling)(
 101                 /*[out,retval]*/ IXMLDOMNode** /*previousSibling*/)VSL_STDMETHOD_NOTIMPL
 102
 103         STDMETHOD(get_nextSibling)(
 104                 /*[out,retval]*/ IXMLDOMNode** /*nextSibling*/)VSL_STDMETHOD_NOTIMPL
 105
 106         STDMETHOD(get_attributes)(
 107                 /*[out,retval]*/ IXMLDOMNamedNodeMap** /*attributeMap*/)VSL_STDMETHOD_NOTIMPL
 108
 109         STDMETHOD(insertBefore)(
 110                 /*[in]*/ IXMLDOMNode* /*newChild*/,
 111                 /*[in]*/ VARIANT /*refChild*/,
 112                 /*[out,retval]*/ IXMLDOMNode** /*outNewChild*/)VSL_STDMETHOD_NOTIMPL
 113
 114         STDMETHOD(replaceChild)(
 115                 /*[in]*/ IXMLDOMNode* /*newChild*/,
 116                 /*[in]*/ IXMLDOMNode* /*oldChild*/,
 117                 /*[out,retval]*/ IXMLDOMNode** /*outOldChild*/)VSL_STDMETHOD_NOTIMPL
 118
 119         STDMETHOD(removeChild)(
 120                 /*[in]*/ IXMLDOMNode* /*childNode*/,
 121                 /*[out,retval]*/ IXMLDOMNode** /*oldChild*/)VSL_STDMETHOD_NOTIMPL
 122
 123         STDMETHOD(appendChild)(
 124                 /*[in]*/ IXMLDOMNode* /*newChild*/,
 125                 /*[out,retval]*/ IXMLDOMNode** /*outNewChild*/)VSL_STDMETHOD_NOTIMPL
 126
 127         STDMETHOD(hasChildNodes)(
 128                 /*[out,retval]*/ VARIANT_BOOL* /*hasChild*/)VSL_STDMETHOD_NOTIMPL
 129
 130         STDMETHOD(get_ownerDocument)(
 131                 /*[out,retval]*/ IXMLDOMDocument** /*DOMDocument*/)VSL_STDMETHOD_NOTIMPL
 132
 133         STDMETHOD(cloneNode)(
 134                 /*[in]*/ VARIANT_BOOL /*deep*/,
 135                 /*[out,retval]*/ IXMLDOMNode** /*cloneRoot*/)VSL_STDMETHOD_NOTIMPL
 136
 137         STDMETHOD(get_nodeTypeString)(
 138                 /*[retval,out]*/ BSTR* /*nodeType*/)VSL_STDMETHOD_NOTIMPL
 139
 140         STDMETHOD(get_text)(
 141                 /*[retval,out]*/ BSTR* /*text*/)VSL_STDMETHOD_NOTIMPL
 142
 143         STDMETHOD(put_text)(
 144                 /*[in]*/ BSTR /*text*/)VSL_STDMETHOD_NOTIMPL
 145
 146         STDMETHOD(get_specified)(
 147                 /*[out,retval]*/ VARIANT_BOOL* /*isSpecified*/)VSL_STDMETHOD_NOTIMPL
 148
 149         STDMETHOD(get_definition)(
 150                 /*[retval,out]*/ IXMLDOMNode** /*definitionNode*/)VSL_STDMETHOD_NOTIMPL
 151
 152         STDMETHOD(get_nodeTypedValue)(
 153                 /*[retval,out]*/ VARIANT* /*typedValue*/)VSL_STDMETHOD_NOTIMPL
 154
 155         STDMETHOD(put_nodeTypedValue)(
 156                 /*[in]*/ VARIANT /*typedValue*/)VSL_STDMETHOD_NOTIMPL
 157
 158         STDMETHOD(get_dataType)(
 159                 /*[retval,out]*/ VARIANT* /*dataTypeName*/)VSL_STDMETHOD_NOTIMPL
 160
 161         STDMETHOD(put_dataType)(
 162                 /*[in]*/ BSTR /*dataTypeName*/)VSL_STDMETHOD_NOTIMPL
 163
 164         STDMETHOD(get_xml)(
 165                 /*[retval,out]*/ BSTR* /*xmlString*/)VSL_STDMETHOD_NOTIMPL
 166
 167         STDMETHOD(transformNode)(
 168                 /*[in]*/ IXMLDOMNode* /*stylesheet*/,
 169                 /*[retval,out]*/ BSTR* /*xmlString*/)VSL_STDMETHOD_NOTIMPL
 170
 171         STDMETHOD(selectNodes)(
 172                 /*[in]*/ BSTR /*queryString*/,
 173                 /*[retval,out]*/ IXMLDOMNodeList** /*resultList*/)VSL_STDMETHOD_NOTIMPL
 174
 175         STDMETHOD(selectSingleNode)(
 176                 /*[in]*/ BSTR /*queryString*/,
 177                 /*[retval,out]*/ IXMLDOMNode** /*resultNode*/)VSL_STDMETHOD_NOTIMPL
 178
 179         STDMETHOD(get_parsed)(
 180                 /*[retval,out]*/ VARIANT_BOOL* /*isParsed*/)VSL_STDMETHOD_NOTIMPL
 181
 182         STDMETHOD(get_namespaceURI)(
 183                 /*[retval,out]*/ BSTR* /*namespaceURI*/)VSL_STDMETHOD_NOTIMPL
 184
 185         STDMETHOD(get_prefix)(
 186                 /*[retval,out]*/ BSTR* /*prefixString*/)VSL_STDMETHOD_NOTIMPL
 187
 188         STDMETHOD(get_baseName)(
 189                 /*[retval,out]*/ BSTR* /*nameString*/)VSL_STDMETHOD_NOTIMPL
 190
 191         STDMETHOD(transformNodeToObject)(
 192                 /*[in]*/ IXMLDOMNode* /*stylesheet*/,
 193                 /*[in]*/ VARIANT /*outputObject*/)VSL_STDMETHOD_NOTIMPL
 194
 195         STDMETHOD(GetTypeInfoCount)(
 196                 /*[out]*/ UINT* /*pctinfo*/)VSL_STDMETHOD_NOTIMPL
 197
 198         STDMETHOD(GetTypeInfo)(
 199                 /*[in]*/ UINT /*iTInfo*/,
 200                 /*[in]*/ LCID /*lcid*/,
 201                 /*[out]*/ ITypeInfo** /*ppTInfo*/)VSL_STDMETHOD_NOTIMPL
 202
 203         STDMETHOD(GetIDsOfNames)(
 204                 /*[in]*/ REFIID /*riid*/,
 205                 /*[in,size_is(cNames)]*/ LPOLESTR* /*rgszNames*/,
 206                 /*[in]*/ UINT /*cNames*/,
 207                 /*[in]*/ LCID /*lcid*/,
 208                 /*[out,size_is(cNames)]*/ DISPID* /*rgDispId*/)VSL_STDMETHOD_NOTIMPL
 209
 210         STDMETHOD(Invoke)(
 211                 /*[in]*/ DISPID /*dispIdMember*/,
 212                 /*[in]*/ REFIID /*riid*/,
 213                 /*[in]*/ LCID /*lcid*/,
 214                 /*[in]*/ WORD /*wFlags*/,
 215                 /*[in,out]*/ DISPPARAMS* /*pDispParams*/,
 216                 /*[out]*/ VARIANT* /*pVarResult*/,
 217                 /*[out]*/ EXCEPINFO* /*pExcepInfo*/,
 218                 /*[out]*/ UINT* /*puArgErr*/)VSL_STDMETHOD_NOTIMPL
 219 };
 220
 221 class IXMLDOMCDATASectionMockImpl :
 222         public IXMLDOMCDATASection,
 223         public MockBase
 224 {
 225
 226 VSL_DECLARE_NONINSTANTIABLE_BASE_CLASS(IXMLDOMCDATASectionMockImpl)
 227
 228 public:
 229
 230 VSL_DEFINE_MOCK_CLASS_TYPDEFS(IXMLDOMCDATASectionMockImpl)
 231
 232         typedef IXMLDOMCDATASection Interface;
 233         struct splitTextValidValues
 234         {
 235                 /*[in]*/ long offset;
 236                 /*[out,retval]*/ IXMLDOMText** rightHandTextNode;
 237                 HRESULT retValue;
 238         };
 239
 240         STDMETHOD(splitText)(
 241                 /*[in]*/ long offset,
 242                 /*[out,retval]*/ IXMLDOMText** rightHandTextNode)
 243         {
 244                 VSL_DEFINE_MOCK_METHOD(splitText)
 245
 246                 VSL_CHECK_VALIDVALUE(offset);
 247
 248                 VSL_SET_VALIDVALUE_INTERFACE(rightHandTextNode);
 249
 250                 VSL_RETURN_VALIDVALUES();
 251         }
 252         struct get_dataValidValues
 253         {
 254                 /*[out,retval]*/ BSTR* data;
 255                 HRESULT retValue;
 256         };
 257
 258         STDMETHOD(get_data)(
 259                 /*[out,retval]*/ BSTR* data)
 260         {
 261                 VSL_DEFINE_MOCK_METHOD(get_data)
 262
 263                 VSL_SET_VALIDVALUE_BSTR(data);
 264
 265                 VSL_RETURN_VALIDVALUES();
 266         }
 267         struct put_dataValidValues
 268         {
 269                 /*[in]*/ BSTR data;
 270                 HRESULT retValue;
 271         };
 272
 273         STDMETHOD(put_data)(
 274                 /*[in]*/ BSTR data)
 275         {
 276                 VSL_DEFINE_MOCK_METHOD(put_data)
 277
 278                 VSL_CHECK_VALIDVALUE_BSTR(data);
 279
 280                 VSL_RETURN_VALIDVALUES();
 281         }
 282         struct get_lengthValidValues
 283         {
 284                 /*[out,retval]*/ long* dataLength;
 285                 HRESULT retValue;
 286         };
 287
 288         STDMETHOD(get_length)(
 289                 /*[out,retval]*/ long* dataLength)
 290         {
 291                 VSL_DEFINE_MOCK_METHOD(get_length)
 292
 293                 VSL_SET_VALIDVALUE(dataLength);
 294
 295                 VSL_RETURN_VALIDVALUES();
 296         }
 297         struct substringDataValidValues
 298         {
 299                 /*[in]*/ long offset;
 300                 /*[in]*/ long count;
 301                 /*[out,retval]*/ BSTR* data;
 302                 HRESULT retValue;
 303         };
 304
 305         STDMETHOD(substringData)(
 306                 /*[in]*/ long offset,
 307                 /*[in]*/ long count,
 308                 /*[out,retval]*/ BSTR* data)
 309         {
 310                 VSL_DEFINE_MOCK_METHOD(substringData)
 311
 312                 VSL_CHECK_VALIDVALUE(offset);
 313
 314                 VSL_CHECK_VALIDVALUE(count);
 315
 316                 VSL_SET_VALIDVALUE_BSTR(data);
 317
 318                 VSL_RETURN_VALIDVALUES();
 319         }
 320         struct appendDataValidValues
 321         {
 322                 /*[in]*/ BSTR data;
 323                 HRESULT retValue;
 324         };
 325
 326         STDMETHOD(appendData)(
 327                 /*[in]*/ BSTR data)
 328         {
 329                 VSL_DEFINE_MOCK_METHOD(appendData)
 330
 331                 VSL_CHECK_VALIDVALUE_BSTR(data);
 332
 333                 VSL_RETURN_VALIDVALUES();
 334         }
 335         struct insertDataValidValues
 336         {
 337                 /*[in]*/ long offset;
 338                 /*[in]*/ BSTR data;
 339                 HRESULT retValue;
 340         };
 341
 342         STDMETHOD(insertData)(
 343                 /*[in]*/ long offset,
 344                 /*[in]*/ BSTR data)
 345         {
 346                 VSL_DEFINE_MOCK_METHOD(insertData)
 347
 348                 VSL_CHECK_VALIDVALUE(offset);
 349
 350                 VSL_CHECK_VALIDVALUE_BSTR(data);
 351
 352                 VSL_RETURN_VALIDVALUES();
 353         }
 354         struct deleteDataValidValues
 355         {
 356                 /*[in]*/ long offset;
 357                 /*[in]*/ long count;
 358                 HRESULT retValue;
 359         };
 360
 361         STDMETHOD(deleteData)(
 362                 /*[in]*/ long offset,
 363                 /*[in]*/ long count)
 364         {
 365                 VSL_DEFINE_MOCK_METHOD(deleteData)
 366
 367                 VSL_CHECK_VALIDVALUE(offset);
 368
 369                 VSL_CHECK_VALIDVALUE(count);
 370
 371                 VSL_RETURN_VALIDVALUES();
 372         }
 373         struct replaceDataValidValues
 374         {
 375                 /*[in]*/ long offset;
 376                 /*[in]*/ long count;
 377                 /*[in]*/ BSTR data;
 378                 HRESULT retValue;
 379         };
 380
 381         STDMETHOD(replaceData)(
 382                 /*[in]*/ long offset,
 383                 /*[in]*/ long count,
 384                 /*[in]*/ BSTR data)
 385         {
 386                 VSL_DEFINE_MOCK_METHOD(replaceData)
 387
 388                 VSL_CHECK_VALIDVALUE(offset);
 389
 390                 VSL_CHECK_VALIDVALUE(count);
 391
 392                 VSL_CHECK_VALIDVALUE_BSTR(data);
 393
 394                 VSL_RETURN_VALIDVALUES();
 395         }
 396         struct get_nodeNameValidValues
 397         {
 398                 /*[out,retval]*/ BSTR* name;
 399                 HRESULT retValue;
 400         };
 401
 402         STDMETHOD(get_nodeName)(
 403                 /*[out,retval]*/ BSTR* name)
 404         {
 405                 VSL_DEFINE_MOCK_METHOD(get_nodeName)
 406
 407                 VSL_SET_VALIDVALUE_BSTR(name);
 408
 409                 VSL_RETURN_VALIDVALUES();
 410         }
 411         struct get_nodeValueValidValues
 412         {
 413                 /*[out,retval]*/ VARIANT* value;
 414                 HRESULT retValue;
 415         };
 416
 417         STDMETHOD(get_nodeValue)(
 418                 /*[out,retval]*/ VARIANT* value)
 419         {
 420                 VSL_DEFINE_MOCK_METHOD(get_nodeValue)
 421
 422                 VSL_SET_VALIDVALUE_VARIANT(value);
 423
 424                 VSL_RETURN_VALIDVALUES();
 425         }
 426         struct put_nodeValueValidValues
 427         {
 428                 /*[in]*/ VARIANT value;
 429                 HRESULT retValue;
 430         };
 431
 432         STDMETHOD(put_nodeValue)(
 433                 /*[in]*/ VARIANT value)
 434         {
 435                 VSL_DEFINE_MOCK_METHOD(put_nodeValue)
 436
 437                 VSL_CHECK_VALIDVALUE(value);
 438
 439                 VSL_RETURN_VALIDVALUES();
 440         }
 441         struct get_nodeTypeValidValues
 442         {
 443                 /*[out,retval]*/ DOMNodeType* type;
 444                 HRESULT retValue;
 445         };
 446
 447         STDMETHOD(get_nodeType)(
 448                 /*[out,retval]*/ DOMNodeType* type)
 449         {
 450                 VSL_DEFINE_MOCK_METHOD(get_nodeType)
 451
 452                 VSL_SET_VALIDVALUE(type);
 453
 454                 VSL_RETURN_VALIDVALUES();
 455         }
 456         struct get_parentNodeValidValues
 457         {
 458                 /*[out,retval]*/ IXMLDOMNode** parent;
 459                 HRESULT retValue;
 460         };
 461
 462         STDMETHOD(get_parentNode)(
 463                 /*[out,retval]*/ IXMLDOMNode** parent)
 464         {
 465                 VSL_DEFINE_MOCK_METHOD(get_parentNode)
 466
 467                 VSL_SET_VALIDVALUE_INTERFACE(parent);
 468
 469                 VSL_RETURN_VALIDVALUES();
 470         }
 471         struct get_childNodesValidValues
 472         {
 473                 /*[out,retval]*/ IXMLDOMNodeList** childList;
 474                 HRESULT retValue;
 475         };
 476
 477         STDMETHOD(get_childNodes)(
 478                 /*[out,retval]*/ IXMLDOMNodeList** childList)
 479         {
 480                 VSL_DEFINE_MOCK_METHOD(get_childNodes)
 481
 482                 VSL_SET_VALIDVALUE_INTERFACE(childList);
 483
 484                 VSL_RETURN_VALIDVALUES();
 485         }
 486         struct get_firstChildValidValues
 487         {
 488                 /*[out,retval]*/ IXMLDOMNode** firstChild;
 489                 HRESULT retValue;
 490         };
 491
 492         STDMETHOD(get_firstChild)(
 493                 /*[out,retval]*/ IXMLDOMNode** firstChild)
 494         {
 495                 VSL_DEFINE_MOCK_METHOD(get_firstChild)
 496
 497                 VSL_SET_VALIDVALUE_INTERFACE(firstChild);
 498
 499                 VSL_RETURN_VALIDVALUES();
 500         }
 501         struct get_lastChildValidValues
 502         {
 503                 /*[out,retval]*/ IXMLDOMNode** lastChild;
 504                 HRESULT retValue;
 505         };
 506
 507         STDMETHOD(get_lastChild)(
 508                 /*[out,retval]*/ IXMLDOMNode** lastChild)
 509         {
 510                 VSL_DEFINE_MOCK_METHOD(get_lastChild)
 511
 512                 VSL_SET_VALIDVALUE_INTERFACE(lastChild);
 513
 514                 VSL_RETURN_VALIDVALUES();
 515         }
 516         struct get_previousSiblingValidValues
 517         {
 518                 /*[out,retval]*/ IXMLDOMNode** previousSibling;
 519                 HRESULT retValue;
 520         };
 521
 522         STDMETHOD(get_previousSibling)(
 523                 /*[out,retval]*/ IXMLDOMNode** previousSibling)
 524         {
 525                 VSL_DEFINE_MOCK_METHOD(get_previousSibling)
 526
 527                 VSL_SET_VALIDVALUE_INTERFACE(previousSibling);
 528
 529                 VSL_RETURN_VALIDVALUES();
 530         }
 531         struct get_nextSiblingValidValues
 532         {
 533                 /*[out,retval]*/ IXMLDOMNode** nextSibling;
 534                 HRESULT retValue;
 535         };
 536
 537         STDMETHOD(get_nextSibling)(
 538                 /*[out,retval]*/ IXMLDOMNode** nextSibling)
 539         {
 540                 VSL_DEFINE_MOCK_METHOD(get_nextSibling)
 541
 542                 VSL_SET_VALIDVALUE_INTERFACE(nextSibling);
 543
 544                 VSL_RETURN_VALIDVALUES();
 545         }
 546         struct get_attributesValidValues
 547         {
 548                 /*[out,retval]*/ IXMLDOMNamedNodeMap** attributeMap;
 549                 HRESULT retValue;
 550         };
 551
 552         STDMETHOD(get_attributes)(
 553                 /*[out,retval]*/ IXMLDOMNamedNodeMap** attributeMap)
 554         {
 555                 VSL_DEFINE_MOCK_METHOD(get_attributes)
 556
 557                 VSL_SET_VALIDVALUE_INTERFACE(attributeMap);
 558
 559                 VSL_RETURN_VALIDVALUES();
 560         }
 561         struct insertBeforeValidValues
 562         {
 563                 /*[in]*/ IXMLDOMNode* newChild;
 564                 /*[in]*/ VARIANT refChild;
 565                 /*[out,retval]*/ IXMLDOMNode** outNewChild;
 566                 HRESULT retValue;
 567         };
 568
 569         STDMETHOD(insertBefore)(
 570                 /*[in]*/ IXMLDOMNode* newChild,
 571                 /*[in]*/ VARIANT refChild,
 572                 /*[out,retval]*/ IXMLDOMNode** outNewChild)
 573         {
 574                 VSL_DEFINE_MOCK_METHOD(insertBefore)
 575
 576                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(newChild);
 577
 578                 VSL_CHECK_VALIDVALUE(refChild);
 579
 580                 VSL_SET_VALIDVALUE_INTERFACE(outNewChild);
 581
 582                 VSL_RETURN_VALIDVALUES();
 583         }
 584         struct replaceChildValidValues
 585         {
 586                 /*[in]*/ IXMLDOMNode* newChild;
 587                 /*[in]*/ IXMLDOMNode* oldChild;
 588                 /*[out,retval]*/ IXMLDOMNode** outOldChild;
 589                 HRESULT retValue;
 590         };
 591
 592         STDMETHOD(replaceChild)(
 593                 /*[in]*/ IXMLDOMNode* newChild,
 594                 /*[in]*/ IXMLDOMNode* oldChild,
 595                 /*[out,retval]*/ IXMLDOMNode** outOldChild)
 596         {
 597                 VSL_DEFINE_MOCK_METHOD(replaceChild)
 598
 599                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(newChild);
 600
 601                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(oldChild);
 602
 603                 VSL_SET_VALIDVALUE_INTERFACE(outOldChild);
 604
 605                 VSL_RETURN_VALIDVALUES();
 606         }
 607         struct removeChildValidValues
 608         {
 609                 /*[in]*/ IXMLDOMNode* childNode;
 610                 /*[out,retval]*/ IXMLDOMNode** oldChild;
 611                 HRESULT retValue;
 612         };
 613
 614         STDMETHOD(removeChild)(
 615                 /*[in]*/ IXMLDOMNode* childNode,
 616                 /*[out,retval]*/ IXMLDOMNode** oldChild)
 617         {
 618                 VSL_DEFINE_MOCK_METHOD(removeChild)
 619
 620                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(childNode);
 621
 622                 VSL_SET_VALIDVALUE_INTERFACE(oldChild);
 623
 624                 VSL_RETURN_VALIDVALUES();
 625         }
 626         struct appendChildValidValues
 627         {
 628                 /*[in]*/ IXMLDOMNode* newChild;
 629                 /*[out,retval]*/ IXMLDOMNode** outNewChild;
 630                 HRESULT retValue;
 631         };
 632
 633         STDMETHOD(appendChild)(
 634                 /*[in]*/ IXMLDOMNode* newChild,
 635                 /*[out,retval]*/ IXMLDOMNode** outNewChild)
 636         {
 637                 VSL_DEFINE_MOCK_METHOD(appendChild)
 638
 639                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(newChild);
 640
 641                 VSL_SET_VALIDVALUE_INTERFACE(outNewChild);
 642
 643                 VSL_RETURN_VALIDVALUES();
 644         }
 645         struct hasChildNodesValidValues
 646         {
 647                 /*[out,retval]*/ VARIANT_BOOL* hasChild;
 648                 HRESULT retValue;
 649         };
 650
 651         STDMETHOD(hasChildNodes)(
 652                 /*[out,retval]*/ VARIANT_BOOL* hasChild)
 653         {
 654                 VSL_DEFINE_MOCK_METHOD(hasChildNodes)
 655
 656                 VSL_SET_VALIDVALUE(hasChild);
 657
 658                 VSL_RETURN_VALIDVALUES();
 659         }
 660         struct get_ownerDocumentValidValues
 661         {
 662                 /*[out,retval]*/ IXMLDOMDocument** DOMDocument;
 663                 HRESULT retValue;
 664         };
 665
 666         STDMETHOD(get_ownerDocument)(
 667                 /*[out,retval]*/ IXMLDOMDocument** DOMDocument)
 668         {
 669                 VSL_DEFINE_MOCK_METHOD(get_ownerDocument)
 670
 671                 VSL_SET_VALIDVALUE_INTERFACE(DOMDocument);
 672
 673                 VSL_RETURN_VALIDVALUES();
 674         }
 675         struct cloneNodeValidValues
 676         {
 677                 /*[in]*/ VARIANT_BOOL deep;
 678                 /*[out,retval]*/ IXMLDOMNode** cloneRoot;
 679                 HRESULT retValue;
 680         };
 681
 682         STDMETHOD(cloneNode)(
 683                 /*[in]*/ VARIANT_BOOL deep,
 684                 /*[out,retval]*/ IXMLDOMNode** cloneRoot)
 685         {
 686                 VSL_DEFINE_MOCK_METHOD(cloneNode)
 687
 688                 VSL_CHECK_VALIDVALUE(deep);
 689
 690                 VSL_SET_VALIDVALUE_INTERFACE(cloneRoot);
 691
 692                 VSL_RETURN_VALIDVALUES();
 693         }
 694         struct get_nodeTypeStringValidValues
 695         {
 696                 /*[retval,out]*/ BSTR* nodeType;
 697                 HRESULT retValue;
 698         };
 699
 700         STDMETHOD(get_nodeTypeString)(
 701                 /*[retval,out]*/ BSTR* nodeType)
 702         {
 703                 VSL_DEFINE_MOCK_METHOD(get_nodeTypeString)
 704
 705                 VSL_SET_VALIDVALUE_BSTR(nodeType);
 706
 707                 VSL_RETURN_VALIDVALUES();
 708         }
 709         struct get_textValidValues
 710         {
 711                 /*[retval,out]*/ BSTR* text;
 712                 HRESULT retValue;
 713         };
 714
 715         STDMETHOD(get_text)(
 716                 /*[retval,out]*/ BSTR* text)
 717         {
 718                 VSL_DEFINE_MOCK_METHOD(get_text)
 719
 720                 VSL_SET_VALIDVALUE_BSTR(text);
 721
 722                 VSL_RETURN_VALIDVALUES();
 723         }
 724         struct put_textValidValues
 725         {
 726                 /*[in]*/ BSTR text;
 727                 HRESULT retValue;
 728         };
 729
 730         STDMETHOD(put_text)(
 731                 /*[in]*/ BSTR text)
 732         {
 733                 VSL_DEFINE_MOCK_METHOD(put_text)
 734
 735                 VSL_CHECK_VALIDVALUE_BSTR(text);
 736
 737                 VSL_RETURN_VALIDVALUES();
 738         }
 739         struct get_specifiedValidValues
 740         {
 741                 /*[out,retval]*/ VARIANT_BOOL* isSpecified;
 742                 HRESULT retValue;
 743         };
 744
 745         STDMETHOD(get_specified)(
 746                 /*[out,retval]*/ VARIANT_BOOL* isSpecified)
 747         {
 748                 VSL_DEFINE_MOCK_METHOD(get_specified)
 749
 750                 VSL_SET_VALIDVALUE(isSpecified);
 751
 752                 VSL_RETURN_VALIDVALUES();
 753         }
 754         struct get_definitionValidValues
 755         {
 756                 /*[retval,out]*/ IXMLDOMNode** definitionNode;
 757                 HRESULT retValue;
 758         };
 759
 760         STDMETHOD(get_definition)(
 761                 /*[retval,out]*/ IXMLDOMNode** definitionNode)
 762         {
 763                 VSL_DEFINE_MOCK_METHOD(get_definition)
 764
 765                 VSL_SET_VALIDVALUE_INTERFACE(definitionNode);
 766
 767                 VSL_RETURN_VALIDVALUES();
 768         }
 769         struct get_nodeTypedValueValidValues
 770         {
 771                 /*[retval,out]*/ VARIANT* typedValue;
 772                 HRESULT retValue;
 773         };
 774
 775         STDMETHOD(get_nodeTypedValue)(
 776                 /*[retval,out]*/ VARIANT* typedValue)
 777         {
 778                 VSL_DEFINE_MOCK_METHOD(get_nodeTypedValue)
 779
 780                 VSL_SET_VALIDVALUE_VARIANT(typedValue);
 781
 782                 VSL_RETURN_VALIDVALUES();
 783         }
 784         struct put_nodeTypedValueValidValues
 785         {
 786                 /*[in]*/ VARIANT typedValue;
 787                 HRESULT retValue;
 788         };
 789
 790         STDMETHOD(put_nodeTypedValue)(
 791                 /*[in]*/ VARIANT typedValue)
 792         {
 793                 VSL_DEFINE_MOCK_METHOD(put_nodeTypedValue)
 794
 795                 VSL_CHECK_VALIDVALUE(typedValue);
 796
 797                 VSL_RETURN_VALIDVALUES();
 798         }
 799         struct get_dataTypeValidValues
 800         {
 801                 /*[retval,out]*/ VARIANT* dataTypeName;
 802                 HRESULT retValue;
 803         };
 804
 805         STDMETHOD(get_dataType)(
 806                 /*[retval,out]*/ VARIANT* dataTypeName)
 807         {
 808                 VSL_DEFINE_MOCK_METHOD(get_dataType)
 809
 810                 VSL_SET_VALIDVALUE_VARIANT(dataTypeName);
 811
 812                 VSL_RETURN_VALIDVALUES();
 813         }
 814         struct put_dataTypeValidValues
 815         {
 816                 /*[in]*/ BSTR dataTypeName;
 817                 HRESULT retValue;
 818         };
 819
 820         STDMETHOD(put_dataType)(
 821                 /*[in]*/ BSTR dataTypeName)
 822         {
 823                 VSL_DEFINE_MOCK_METHOD(put_dataType)
 824
 825                 VSL_CHECK_VALIDVALUE_BSTR(dataTypeName);
 826
 827                 VSL_RETURN_VALIDVALUES();
 828         }
 829         struct get_xmlValidValues
 830         {
 831                 /*[retval,out]*/ BSTR* xmlString;
 832                 HRESULT retValue;
 833         };
 834
 835         STDMETHOD(get_xml)(
 836                 /*[retval,out]*/ BSTR* xmlString)
 837         {
 838                 VSL_DEFINE_MOCK_METHOD(get_xml)
 839
 840                 VSL_SET_VALIDVALUE_BSTR(xmlString);
 841
 842                 VSL_RETURN_VALIDVALUES();
 843         }
 844         struct transformNodeValidValues
 845         {
 846                 /*[in]*/ IXMLDOMNode* stylesheet;
 847                 /*[retval,out]*/ BSTR* xmlString;
 848                 HRESULT retValue;
 849         };
 850
 851         STDMETHOD(transformNode)(
 852                 /*[in]*/ IXMLDOMNode* stylesheet,
 853                 /*[retval,out]*/ BSTR* xmlString)
 854         {
 855                 VSL_DEFINE_MOCK_METHOD(transformNode)
 856
 857                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(stylesheet);
 858
 859                 VSL_SET_VALIDVALUE_BSTR(xmlString);
 860
 861                 VSL_RETURN_VALIDVALUES();
 862         }
 863         struct selectNodesValidValues
 864         {
 865                 /*[in]*/ BSTR queryString;
 866                 /*[retval,out]*/ IXMLDOMNodeList** resultList;
 867                 HRESULT retValue;
 868         };
 869
 870         STDMETHOD(selectNodes)(
 871                 /*[in]*/ BSTR queryString,
 872                 /*[retval,out]*/ IXMLDOMNodeList** resultList)
 873         {
 874                 VSL_DEFINE_MOCK_METHOD(selectNodes)
 875
 876                 VSL_CHECK_VALIDVALUE_BSTR(queryString);
 877
 878                 VSL_SET_VALIDVALUE_INTERFACE(resultList);
 879
 880                 VSL_RETURN_VALIDVALUES();
 881         }
 882         struct selectSingleNodeValidValues
 883         {
 884                 /*[in]*/ BSTR queryString;
 885                 /*[retval,out]*/ IXMLDOMNode** resultNode;
 886                 HRESULT retValue;
 887         };
 888
 889         STDMETHOD(selectSingleNode)(
 890                 /*[in]*/ BSTR queryString,
 891                 /*[retval,out]*/ IXMLDOMNode** resultNode)
 892         {
 893                 VSL_DEFINE_MOCK_METHOD(selectSingleNode)
 894
 895                 VSL_CHECK_VALIDVALUE_BSTR(queryString);
 896
 897                 VSL_SET_VALIDVALUE_INTERFACE(resultNode);
 898
 899                 VSL_RETURN_VALIDVALUES();
 900         }
 901         struct get_parsedValidValues
 902         {
 903                 /*[retval,out]*/ VARIANT_BOOL* isParsed;
 904                 HRESULT retValue;
 905         };
 906
 907         STDMETHOD(get_parsed)(
 908                 /*[retval,out]*/ VARIANT_BOOL* isParsed)
 909         {
 910                 VSL_DEFINE_MOCK_METHOD(get_parsed)
 911
 912                 VSL_SET_VALIDVALUE(isParsed);
 913
 914                 VSL_RETURN_VALIDVALUES();
 915         }
 916         struct get_namespaceURIValidValues
 917         {
 918                 /*[retval,out]*/ BSTR* namespaceURI;
 919                 HRESULT retValue;
 920         };
 921
 922         STDMETHOD(get_namespaceURI)(
 923                 /*[retval,out]*/ BSTR* namespaceURI)
 924         {
 925                 VSL_DEFINE_MOCK_METHOD(get_namespaceURI)
 926
 927                 VSL_SET_VALIDVALUE_BSTR(namespaceURI);
 928
 929                 VSL_RETURN_VALIDVALUES();
 930         }
 931         struct get_prefixValidValues
 932         {
 933                 /*[retval,out]*/ BSTR* prefixString;
 934                 HRESULT retValue;
 935         };
 936
 937         STDMETHOD(get_prefix)(
 938                 /*[retval,out]*/ BSTR* prefixString)
 939         {
 940                 VSL_DEFINE_MOCK_METHOD(get_prefix)
 941
 942                 VSL_SET_VALIDVALUE_BSTR(prefixString);
 943
 944                 VSL_RETURN_VALIDVALUES();
 945         }
 946         struct get_baseNameValidValues
 947         {
 948                 /*[retval,out]*/ BSTR* nameString;
 949                 HRESULT retValue;
 950         };
 951
 952         STDMETHOD(get_baseName)(
 953                 /*[retval,out]*/ BSTR* nameString)
 954         {
 955                 VSL_DEFINE_MOCK_METHOD(get_baseName)
 956
 957                 VSL_SET_VALIDVALUE_BSTR(nameString);
 958
 959                 VSL_RETURN_VALIDVALUES();
 960         }
 961         struct transformNodeToObjectValidValues
 962         {
 963                 /*[in]*/ IXMLDOMNode* stylesheet;
 964                 /*[in]*/ VARIANT outputObject;
 965                 HRESULT retValue;
 966         };
 967
 968         STDMETHOD(transformNodeToObject)(
 969                 /*[in]*/ IXMLDOMNode* stylesheet,
 970                 /*[in]*/ VARIANT outputObject)
 971         {
 972                 VSL_DEFINE_MOCK_METHOD(transformNodeToObject)
 973
 974                 VSL_CHECK_VALIDVALUE_INTERFACEPOINTER(stylesheet);
 975
 976                 VSL_CHECK_VALIDVALUE(outputObject);
 977
 978                 VSL_RETURN_VALIDVALUES();
 979         }
 980         struct GetTypeInfoCountValidValues
 981         {
 982                 /*[out]*/ UINT* pctinfo;
 983                 HRESULT retValue;
 984         };
 985
 986         STDMETHOD(GetTypeInfoCount)(
 987                 /*[out]*/ UINT* pctinfo)
 988         {
 989                 VSL_DEFINE_MOCK_METHOD(GetTypeInfoCount)
 990
 991                 VSL_SET_VALIDVALUE(pctinfo);
 992
 993                 VSL_RETURN_VALIDVALUES();
 994         }
 995         struct GetTypeInfoValidValues
 996         {
 997                 /*[in]*/ UINT iTInfo;
 998                 /*[in]*/ LCID lcid;
 999                 /*[out]*/ ITypeInfo** ppTInfo;
1000                 HRESULT retValue;
1001         };
1002
1003         STDMETHOD(GetTypeInfo)(
1004                 /*[in]*/ UINT iTInfo,
1005                 /*[in]*/ LCID lcid,
1006                 /*[out]*/ ITypeInfo** ppTInfo)
1007         {
1008                 VSL_DEFINE_MOCK_METHOD(GetTypeInfo)
1009
1010                 VSL_CHECK_VALIDVALUE(iTInfo);
1011
1012                 VSL_CHECK_VALIDVALUE(lcid);
1013
1014                 VSL_SET_VALIDVALUE_INTERFACE(ppTInfo);
1015
1016                 VSL_RETURN_VALIDVALUES();
1017         }
1018         struct GetIDsOfNamesValidValues
1019         {
1020                 /*[in]*/ REFIID riid;
1021                 /*[in,size_is(cNames)]*/ LPOLESTR* rgszNames;
1022                 /*[in]*/ UINT cNames;
1023                 /*[in]*/ LCID lcid;
1024                 /*[out,size_is(cNames)]*/ DISPID* rgDispId;
1025                 HRESULT retValue;
1026         };
1027
1028         STDMETHOD(GetIDsOfNames)(
1029                 /*[in]*/ REFIID riid,
1030                 /*[in,size_is(cNames)]*/ LPOLESTR* rgszNames,
1031                 /*[in]*/ UINT cNames,
1032                 /*[in]*/ LCID lcid,
1033                 /*[out,size_is(cNames)]*/ DISPID* rgDispId)
1034         {
1035                 VSL_DEFINE_MOCK_METHOD(GetIDsOfNames)
1036
1037                 VSL_CHECK_VALIDVALUE(riid);
1038
1039                 VSL_CHECK_VALIDVALUE_MEMCMP(rgszNames, cNames*sizeof(rgszNames[0]), validValues.cNames*sizeof(validValues.rgszNames[0]));
1040
1041                 VSL_CHECK_VALIDVALUE(cNames);
1042
1043                 VSL_CHECK_VALIDVALUE(lcid);
1044
1045                 VSL_SET_VALIDVALUE_MEMCPY(rgDispId, cNames*sizeof(rgDispId[0]), validValues.cNames*sizeof(validValues.rgDispId[0]));
1046
1047                 VSL_RETURN_VALIDVALUES();
1048         }
1049         struct InvokeValidValues
1050         {
1051                 /*[in]*/ DISPID dispIdMember;
1052                 /*[in]*/ REFIID riid;
1053                 /*[in]*/ LCID lcid;
1054                 /*[in]*/ WORD wFlags;
1055                 /*[in,out]*/ DISPPARAMS* pDispParams;
1056                 /*[out]*/ VARIANT* pVarResult;
1057                 /*[out]*/ EXCEPINFO* pExcepInfo;
1058                 /*[out]*/ UINT* puArgErr;
1059                 HRESULT retValue;
1060         };
1061
1062         STDMETHOD(Invoke)(
1063                 /*[in]*/ DISPID dispIdMember,
1064                 /*[in]*/ REFIID riid,
1065                 /*[in]*/ LCID lcid,
1066                 /*[in]*/ WORD wFlags,
1067                 /*[in,out]*/ DISPPARAMS* pDispParams,
1068                 /*[out]*/ VARIANT* pVarResult,
1069                 /*[out]*/ EXCEPINFO* pExcepInfo,
1070                 /*[out]*/ UINT* puArgErr)
1071         {
1072                 VSL_DEFINE_MOCK_METHOD(Invoke)
1073
1074                 VSL_CHECK_VALIDVALUE(dispIdMember);
1075
1076                 VSL_CHECK_VALIDVALUE(riid);
1077
1078                 VSL_CHECK_VALIDVALUE(lcid);
1079
1080                 VSL_CHECK_VALIDVALUE(wFlags);
1081
1082                 VSL_SET_VALIDVALUE(pDispParams);
1083
1084                 VSL_SET_VALIDVALUE_VARIANT(pVarResult);
1085
1086                 VSL_SET_VALIDVALUE(pExcepInfo);
1087
1088                 VSL_SET_VALIDVALUE(puArgErr);
1089
1090                 VSL_RETURN_VALIDVALUES();
1091         }
1092 };
1093
1094
1095 } // namespace VSL
1096
1097 #pragma warning(pop)
1098
1099 #endif // IXMLDOMCDATASECTION_H_10C49CA1_2F46_11D3_A504_00C04F5E0BA5