dlls/msxml3/tests/schema.c

   1 /*
   2  * Schema test
   3  *
   4  * Copyright 2007 Huw Davies
   5  * Copyright 2010 Adam Martinson for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <assert.h>
  24 #define COBJMACROS
  25
  26 #include "initguid.h"
  27 #include "windows.h"
  28 #include "ole2.h"
  29 #include "msxml2.h"
  30 #include "msxml2did.h"
  31 #include "dispex.h"
  32
  33 #include "wine/test.h"
  34
  35 #define EXPECT_HR(hr,hr_exp) \
  36     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
  37
  38 static const WCHAR xdr_schema_uri[] = {'x','-','s','c','h','e','m','a',':','t','e','s','t','.','x','m','l',0};
  39
  40 static const WCHAR xdr_schema_xml[] = {
  41     '<','S','c','h','e','m','a',' ','x','m','l','n','s','=','\"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','x','m','l','-','d','a','t','a','\"','\n',
  42     'x','m','l','n','s',':','d','t','=','\"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','d','a','t','a','t','y','p','e','s','\"','>','\n',
  43     '<','/','S','c','h','e','m','a','>','\n',0
  44 };
  45
  46 static const CHAR xdr_schema1_uri[] = "x-schema:test1.xdr";
  47 static const CHAR xdr_schema1_xml[] =
  48 "<?xml version='1.0'?>"
  49 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'"
  50 "        xmlns:dt='urn:schemas-microsoft-com:datatypes'"
  51 "        name='test1.xdr'>"
  52 "   <ElementType name='x' dt:type='boolean'/>"
  53 "   <ElementType name='y'>"
  54 "       <datatype dt:type='int'/>"
  55 "   </ElementType>"
  56 "   <ElementType name='z'/>"
  57 "   <ElementType name='root' content='eltOnly' model='open' order='seq'>"
  58 "       <element type='x'/>"
  59 "       <element type='y'/>"
  60 "       <element type='z'/>"
  61 "   </ElementType>"
  62 "</Schema>";
  63
  64 static const CHAR xdr_schema2_uri[] = "x-schema:test2.xdr";
  65 static const CHAR xdr_schema2_xml[] =
  66 "<?xml version='1.0'?>"
  67 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'"
  68 "        xmlns:dt='urn:schemas-microsoft-com:datatypes'"
  69 "        name='test2.xdr'>"
  70 "   <ElementType name='x' dt:type='bin.base64'/>"
  71 "   <ElementType name='y' dt:type='uuid'/>"
  72 "   <ElementType name='z'/>"
  73 "   <ElementType name='root' content='eltOnly' model='closed' order='one'>"
  74 "       <element type='x'/>"
  75 "       <element type='y'/>"
  76 "       <element type='z'/>"
  77 "   </ElementType>"
  78 "</Schema>";
  79
  80 static const CHAR xdr_schema3_uri[] = "x-schema:test3.xdr";
  81 static const CHAR xdr_schema3_xml[] =
  82 "<?xml version='1.0'?>"
  83 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'"
  84 "        xmlns:dt='urn:schemas-microsoft-com:datatypes'"
  85 "        name='test3.xdr'>"
  86 "   <ElementType name='root' content='textOnly' model='open'>"
  87 "       <AttributeType name='x' dt:type='int'/>"
  88 "       <AttributeType name='y' dt:type='enumeration' dt:values='a b c'/>"
  89 "       <AttributeType name='z' dt:type='uuid'/>"
  90 "       <attribute type='x'/>"
  91 "       <attribute type='y'/>"
  92 "       <attribute type='z'/>"
  93 "   </ElementType>"
  94 "</Schema>";
  95
  96 static const CHAR xsd_schema1_uri[] = "x-schema:test1.xsd";
  97 static const CHAR xsd_schema1_xml[] =
  98 "<?xml version='1.0'?>"
  99 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
 100 "            targetNamespace='x-schema:test1.xsd'>"
 101 "   <element name='root'>"
 102 "       <complexType>"
 103 "           <sequence maxOccurs='unbounded'>"
 104 "               <any/>"
 105 "           </sequence>"
 106 "       </complexType>"
 107 "   </element>"
 108 "</schema>";
 109
 110 static const CHAR xsd_schema2_uri[] = "x-schema:test2.xsd";
 111 static const CHAR xsd_schema2_xml[] =
 112 "<?xml version='1.0'?>"
 113 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
 114 "            targetNamespace='x-schema:test2.xsd'>"
 115 "   <element name='root'>"
 116 "       <complexType>"
 117 "           <sequence maxOccurs='unbounded'>"
 118 "               <any/>"
 119 "           </sequence>"
 120 "       </complexType>"
 121 "   </element>"
 122 "</schema>";
 123
 124 static const CHAR xsd_schema3_uri[] = "x-schema:test3.xsd";
 125 static const CHAR xsd_schema3_xml[] =
 126 "<?xml version='1.0'?>"
 127 "<schema xmlns='http://www.w3.org/2001/XMLSchema'"
 128 "            targetNamespace='x-schema:test3.xsd'>"
 129 "   <element name='root'>"
 130 "       <complexType>"
 131 "           <sequence maxOccurs='unbounded'>"
 132 "               <any/>"
 133 "           </sequence>"
 134 "       </complexType>"
 135 "   </element>"
 136 "</schema>";
 137
 138 static const CHAR szDatatypeXDR[] =
 139 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'\n"
 140 "        xmlns:dt='urn:schemas-microsoft-com:datatypes'>\n"
 141 "   <ElementType name='base64Data' content='textOnly' dt:type='bin.base64'/>\n"
 142 "   <ElementType name='hexData' content='textOnly' dt:type='bin.hex'/>\n"
 143 "   <ElementType name='boolData' content='textOnly' dt:type='boolean'/>\n"
 144 "   <ElementType name='charData' content='textOnly' dt:type='char'/>\n"
 145 "   <ElementType name='dateData' content='textOnly' dt:type='date'/>\n"
 146 "   <ElementType name='dateTimeData' content='textOnly' dt:type='dateTime'/>\n"
 147 "   <ElementType name='dateTimeTzData' content='textOnly' dt:type='dateTime.tz'/>\n"
 148 "   <ElementType name='entityData' content='textOnly' dt:type='entity'/>\n"
 149 "   <ElementType name='entitiesData' content='textOnly' dt:type='entities'/>\n"
 150 "   <ElementType name='fixedData' content='textOnly' dt:type='fixed.14.4'/>\n"
 151 "   <ElementType name='floatData' content='textOnly' dt:type='float'/>\n"
 152 "   <ElementType name='i1Data' content='textOnly' dt:type='i1'/>\n"
 153 "   <ElementType name='i2Data' content='textOnly' dt:type='i2'/>\n"
 154 "   <ElementType name='i4Data' content='textOnly' dt:type='i4'/>\n"
 155 "   <ElementType name='i8Data' content='textOnly' dt:type='i8'/>\n"
 156 "   <ElementType name='intData' content='textOnly' dt:type='int'/>\n"
 157 "   <ElementType name='nmtokData' content='textOnly' dt:type='nmtoken'/>\n"
 158 "   <ElementType name='nmtoksData' content='textOnly' dt:type='nmtokens'/>\n"
 159 "   <ElementType name='numData' content='textOnly' dt:type='number'/>\n"
 160 "   <ElementType name='r4Data' content='textOnly' dt:type='r4'/>\n"
 161 "   <ElementType name='r8Data' content='textOnly' dt:type='r8'/>\n"
 162 "   <ElementType name='stringData' content='textOnly' dt:type='string'/>\n"
 163 "   <ElementType name='timeData' content='textOnly' dt:type='time'/>\n"
 164 "   <ElementType name='timeTzData' content='textOnly' dt:type='time.tz'/>\n"
 165 "   <ElementType name='u1Data' content='textOnly' dt:type='ui1'/>\n"
 166 "   <ElementType name='u2Data' content='textOnly' dt:type='ui2'/>\n"
 167 "   <ElementType name='u4Data' content='textOnly' dt:type='ui4'/>\n"
 168 "   <ElementType name='u8Data' content='textOnly' dt:type='ui8'/>\n"
 169 "   <ElementType name='uriData' content='textOnly' dt:type='uri'/>\n"
 170 "   <ElementType name='uuidData' content='textOnly' dt:type='uuid'/>\n"
 171 "\n"
 172 "   <ElementType name='Name' content='textOnly' dt:type='nmtoken'/>\n"
 173 "   <ElementType name='Value' content='eltOnly' order='many'>\n"
 174 "       <element type='base64Data'/>\n"
 175 "       <element type='hexData'/>\n"
 176 "       <element type='boolData'/>\n"
 177 "       <element type='charData'/>\n"
 178 "       <element type='dateData'/>\n"
 179 "       <element type='dateTimeData'/>\n"
 180 "       <element type='dateTimeTzData'/>\n"
 181 "       <element type='entityData'/>\n"
 182 "       <element type='entitiesData'/>\n"
 183 "       <element type='fixedData'/>\n"
 184 "       <element type='floatData'/>\n"
 185 "       <element type='i1Data'/>\n"
 186 "       <element type='i2Data'/>\n"
 187 "       <element type='i4Data'/>\n"
 188 "       <element type='i8Data'/>\n"
 189 "       <element type='intData'/>\n"
 190 "       <element type='nmtokData'/>\n"
 191 "       <element type='nmtoksData'/>\n"
 192 "       <element type='numData'/>\n"
 193 "       <element type='r4Data'/>\n"
 194 "       <element type='r8Data'/>\n"
 195 "       <element type='stringData'/>\n"
 196 "       <element type='timeData'/>\n"
 197 "       <element type='timeTzData'/>\n"
 198 "       <element type='u1Data'/>\n"
 199 "       <element type='u2Data'/>\n"
 200 "       <element type='u4Data'/>\n"
 201 "       <element type='u8Data'/>\n"
 202 "       <element type='uriData'/>\n"
 203 "       <element type='uuidData'/>\n"
 204 "   </ElementType>\n"
 205 "   <ElementType name='Property' content='eltOnly' order='seq'>\n"
 206 "       <element type='Name'/>\n"
 207 "       <element type='Value'/>\n"
 208 "   </ElementType>\n"
 209 "   <ElementType name='Properties' content='eltOnly'>\n"
 210 "       <element type='Property' minOccurs='0' maxOccurs='*'/>\n"
 211 "   </ElementType>\n"
 212 "</Schema>";
 213
 214 static const CHAR szDatatypeXML[] =
 215 "<?xml version='1.0'?>\n"
 216 "<Properties xmlns='urn:x-schema:datatype-test-xdr'>\n"
 217 "   <Property>\n"
 218 "       <Name>testBase64</Name>\n"
 219 "       <Value>\n"
 220 "           <base64Data>+HugeNumber+</base64Data>\n"
 221 "       </Value>\n"
 222 "   </Property>\n"
 223 "   <Property>\n"
 224 "       <Name>testHex</Name>\n"
 225 "       <Value>\n"
 226 "           <hexData>deadbeef</hexData>\n"
 227 "       </Value>\n"
 228 "   </Property>\n"
 229 "   <Property>\n"
 230 "       <Name>testBool</Name>\n"
 231 "       <Value>\n"
 232 "           <boolData>1</boolData>\n"
 233 "       </Value>\n"
 234 "   </Property>\n"
 235 "   <Property>\n"
 236 "       <Name>testChar</Name>\n"
 237 "       <Value>\n"
 238 "           <charData>u</charData>\n"
 239 "       </Value>\n"
 240 "   </Property>\n"
 241 "   <Property>\n"
 242 "       <Name>testDate</Name>\n"
 243 "       <Value>\n"
 244 "           <dateData>1998-02-01</dateData>\n"
 245 "       </Value>\n"
 246 "   </Property>\n"
 247 "   <Property>\n"
 248 "       <Name>testDateTime</Name>\n"
 249 "       <Value>\n"
 250 "           <dateTimeData>1998-02-01T12:34:56</dateTimeData>\n"
 251 "       </Value>\n"
 252 "   </Property>\n"
 253 "   <Property>\n"
 254 "       <Name>testDateTimeTz</Name>\n"
 255 "       <Value>\n"
 256 "           <dateTimeTzData>1998-02-01T12:34:56-06:00</dateTimeTzData>\n"
 257 "       </Value>\n"
 258 "   </Property>\n"
 259 "   <Property>\n"
 260 "       <Name>testFixed</Name>\n"
 261 "       <Value>\n"
 262 "           <fixedData>3.1416</fixedData>\n"
 263 "       </Value>\n"
 264 "   </Property>\n"
 265 "   <Property>\n"
 266 "       <Name>testFloat</Name>\n"
 267 "       <Value>\n"
 268 "           <floatData>3.14159</floatData>\n"
 269 "       </Value>\n"
 270 "   </Property>\n"
 271 "   <Property>\n"
 272 "       <Name>testI1</Name>\n"
 273 "       <Value>\n"
 274 "           <i1Data>42</i1Data>\n"
 275 "       </Value>\n"
 276 "   </Property>\n"
 277 "   <Property>\n"
 278 "       <Name>testI2</Name>\n"
 279 "       <Value>\n"
 280 "           <i2Data>420</i2Data>\n"
 281 "       </Value>\n"
 282 "   </Property>\n"
 283 "   <Property>\n"
 284 "       <Name>testI4</Name>\n"
 285 "       <Value>\n"
 286 "           <i4Data>-420000000</i4Data>\n"
 287 "       </Value>\n"
 288 "   </Property>\n"
 289 "   <Property>\n"
 290 "       <Name>testI8</Name>\n"
 291 "       <Value>\n"
 292 "           <i8Data>-4200000000</i8Data>\n"
 293 "       </Value>\n"
 294 "   </Property>\n"
 295 "   <Property>\n"
 296 "       <Name>testInt</Name>\n"
 297 "       <Value>\n"
 298 "           <intData>42</intData>\n"
 299 "       </Value>\n"
 300 "   </Property>\n"
 301 "   <Property>\n"
 302 "       <Name>testNmtoken</Name>\n"
 303 "       <Value>\n"
 304 "           <nmtokData>tok1</nmtokData>\n"
 305 "       </Value>\n"
 306 "   </Property>\n"
 307 "   <Property>\n"
 308 "       <Name>testNmtokens</Name>\n"
 309 "       <Value>\n"
 310 "           <nmtoksData>tok1 tok2 tok3</nmtoksData>\n"
 311 "       </Value>\n"
 312 "   </Property>\n"
 313 "   <Property>\n"
 314 "       <Name>testNumber</Name>\n"
 315 "       <Value>\n"
 316 "           <numData>3.14159</numData>\n"
 317 "       </Value>\n"
 318 "   </Property>\n"
 319 "   <Property>\n"
 320 "       <Name>testR4</Name>\n"
 321 "       <Value>\n"
 322 "           <r4Data>3.14159265</r4Data>\n"
 323 "       </Value>\n"
 324 "   </Property>\n"
 325 "   <Property>\n"
 326 "       <Name>testR8</Name>\n"
 327 "       <Value>\n"
 328 "           <r8Data>3.14159265358979323846</r8Data>\n"
 329 "       </Value>\n"
 330 "   </Property>\n"
 331 "   <Property>\n"
 332 "       <Name>testString</Name>\n"
 333 "       <Value>\n"
 334 "           <stringData>foo bar</stringData>\n"
 335 "       </Value>\n"
 336 "   </Property>\n"
 337 "   <Property>\n"
 338 "       <Name>testTime</Name>\n"
 339 "       <Value>\n"
 340 "           <timeData>12:34:56</timeData>\n"
 341 "       </Value>\n"
 342 "   </Property>\n"
 343 "   <Property>\n"
 344 "       <Name>testTimeTz</Name>\n"
 345 "       <Value>\n"
 346 "           <timeTzData>12:34:56-06:00</timeTzData>\n"
 347 "       </Value>\n"
 348 "   </Property>\n"
 349 "   <Property>\n"
 350 "       <Name>testU1</Name>\n"
 351 "       <Value>\n"
 352 "           <u1Data>255</u1Data>\n"
 353 "       </Value>\n"
 354 "   </Property>\n"
 355 "   <Property>\n"
 356 "       <Name>testU2</Name>\n"
 357 "       <Value>\n"
 358 "           <u2Data>65535</u2Data>\n"
 359 "       </Value>\n"
 360 "   </Property>\n"
 361 "   <Property>\n"
 362 "       <Name>testU4</Name>\n"
 363 "       <Value>\n"
 364 "           <u4Data>4294967295</u4Data>\n"
 365 "       </Value>\n"
 366 "   </Property>\n"
 367 "   <Property>\n"
 368 "       <Name>testU8</Name>\n"
 369 "       <Value>\n"
 370 "           <u8Data>18446744073709551615</u8Data>\n"
 371 "       </Value>\n"
 372 "   </Property>\n"
 373 "   <Property>\n"
 374 "       <Name>testURI</Name>\n"
 375 "       <Value>\n"
 376 "           <uriData>urn:schemas-microsoft-com:datatypes</uriData>\n"
 377 "       </Value>\n"
 378 "   </Property>\n"
 379 "   <Property>\n"
 380 "       <Name>testUUID</Name>\n"
 381 "       <Value>\n"
 382 "           <uuidData>2933BF81-7B36-11D2-B20E-00C04F983E60</uuidData>\n"
 383 "       </Value>\n"
 384 "   </Property>\n"
 385 "</Properties>";
 386
 387 static const CHAR szOpenSeqXDR[] =
 388 "<Schema xmlns='urn:schemas-microsoft-com:xml-data'>\n"
 389 "   <ElementType name='w' content='empty' model='closed'/>\n"
 390 "   <ElementType name='x' content='empty' model='closed'/>\n"
 391 "   <ElementType name='y' content='empty' model='closed'/>\n"
 392 "   <ElementType name='z' content='empty' model='closed'/>\n"
 393 "   <ElementType name='test' content='eltOnly' model='open' order='seq'>\n"
 394 "       <element type='x'/>\n"
 395 "       <group order='seq'>\n"
 396 "           <element type='x'/>\n"
 397 "           <element type='y'/>\n"
 398 "           <element type='z'/>\n"
 399 "       </group>\n"
 400 "       <element type='z'/>\n"
 401 "   </ElementType>\n"
 402 "</Schema>";
 403
 404 static const CHAR szOpenSeqXML1[] = "<test><x/><x/><y/><z/><z/></test>";
 405 static const CHAR szOpenSeqXML2[] = "<test><x/><x/><y/><z/><z/><w/></test>";
 406 static const CHAR szOpenSeqXML3[] = "<test><w/><x/><x/><y/><z/><z/></test>";
 407 static const CHAR szOpenSeqXML4[] = "<test><x/><x/><y/><z/><z/><v/></test>";
 408
 409 #define check_ref_expr(expr, n) { \
 410     LONG ref = expr; \
 411     ok(ref == n, "expected %i refs, got %i\n", n, ref); \
 412 }
 413
 414 #define check_refs(iface, obj, n) { \
 415     LONG ref = iface ## _AddRef(obj); \
 416     ok(ref == n+1, "expected %i refs, got %i\n", n+1, ref); \
 417     ref = iface ## _Release(obj); \
 418     ok(ref == n, "expected %i refs, got %i\n", n, ref); \
 419 }
 420
 421 #define ole_check(expr) { \
 422     HRESULT r = expr; \
 423     ok(r == S_OK, #expr " returned %x\n", r); \
 424 }
 425
 426 #define ole_expect(expr, expect) { \
 427     HRESULT r = expr; \
 428     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 429 }
 430
 431 #define _expect64(expr, str, base, TYPE, CONV) { \
 432     TYPE v1 = expr; \
 433     TYPE v2 = CONV(str, NULL, base); \
 434     ok(v1 == v2, #expr "returned 0x%08x%08x, expected 0x%08x%08x\n", \
 435                   (ULONG)((ULONG64)v1 >> 32), (ULONG)((ULONG64)v2 & (ULONG64)0xffffffff), \
 436                   (ULONG)((ULONG64)v1 >> 32), (ULONG)((ULONG64)v2 & (ULONG64)0xffffffff)); \
 437 }
 438
 439 #define expect_int64(expr, x, base) _expect64(expr, #x, base, LONG64, strtoll)
 440 #define expect_uint64(expr, x, base) _expect64(expr, #x, base, ULONG64, strtoull)
 441
 442 static BSTR alloced_bstrs[256];
 443 static int alloced_bstrs_count;
 444
 445 static BSTR alloc_str_from_narrow(const char *str)
 446 {
 447     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 448     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 449     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 450     return ret;
 451 }
 452
 453 static BSTR _bstr_(const char *str)
 454 {
 455     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 456     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 457     return alloced_bstrs[alloced_bstrs_count++];
 458 }
 459
 460 static void free_bstrs(void)
 461 {
 462     int i;
 463     for (i = 0; i < alloced_bstrs_count; i++)
 464         SysFreeString(alloced_bstrs[i]);
 465     alloced_bstrs_count = 0;
 466 }
 467
 468 static VARIANT _variantdoc_(void* doc)
 469 {
 470     VARIANT v;
 471     V_VT(&v) = VT_DISPATCH;
 472     V_DISPATCH(&v) = (IDispatch*)doc;
 473     return v;
 474 }
 475
 476 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
 477 {
 478     void *obj = NULL;
 479     HRESULT hr;
 480
 481     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
 482     if (hr != S_OK)
 483         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
 484
 485     return obj;
 486 }
 487
 488 #define _create(cls) cls, #cls
 489
 490 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument), iid, __LINE__)
 491
 492 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
 493
 494 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
 495
 496 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
 497
 498 static void test_schema_refs(void)
 499 {
 500     static const WCHAR emptyW[] = {0};
 501     IXMLDOMDocument2 *doc;
 502     IXMLDOMNode *node;
 503     IXMLDOMSchemaCollection *cache;
 504     VARIANT v;
 505     VARIANT_BOOL b;
 506     BSTR str;
 507     LONG len;
 508
 509     doc = create_document(&IID_IXMLDOMDocument2);
 510     if (!doc)
 511         return;
 512
 513     cache = create_cache(&IID_IXMLDOMSchemaCollection);
 514     if(!cache)
 515     {
 516         IXMLDOMDocument2_Release(doc);
 517         return;
 518     }
 519
 520     VariantInit(&v);
 521     str = SysAllocString(xdr_schema_xml);
 522     ole_check(IXMLDOMDocument2_loadXML(doc, str, &b));
 523     ok(b == VARIANT_TRUE, "b %04x\n", b);
 524     SysFreeString(str);
 525
 526     node = (void*)0xdeadbeef;
 527     ole_check(IXMLDOMSchemaCollection_get(cache, NULL, &node));
 528     ok(node == NULL, "%p\n", node);
 529
 530     /* NULL uri pointer, still adds a document */
 531     ole_check(IXMLDOMSchemaCollection_add(cache, NULL, _variantdoc_(doc)));
 532     len = -1;
 533     ole_check(IXMLDOMSchemaCollection_get_length(cache, &len));
 534     ok(len == 1, "got %d\n", len);
 535     /* read back - empty valid BSTR */
 536     str = NULL;
 537     ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache, 0, &str));
 538     ok(str && *str == 0, "got %p\n", str);
 539     SysFreeString(str);
 540
 541     node = NULL;
 542     ole_check(IXMLDOMSchemaCollection_get(cache, NULL, &node));
 543     ok(node != NULL, "%p\n", node);
 544     IXMLDOMNode_Release(node);
 545
 546     node = NULL;
 547     str = SysAllocString(emptyW);
 548     ole_check(IXMLDOMSchemaCollection_get(cache, str, &node));
 549     ok(node != NULL, "%p\n", node);
 550     IXMLDOMNode_Release(node);
 551     SysFreeString(str);
 552
 553     /* remove with NULL uri */
 554     ole_check(IXMLDOMSchemaCollection_remove(cache, NULL));
 555     len = -1;
 556     ole_check(IXMLDOMSchemaCollection_get_length(cache, &len));
 557     ok(len == 0, "got %d\n", len);
 558
 559     str = SysAllocString(xdr_schema_uri);
 560     ole_check(IXMLDOMSchemaCollection_add(cache, str, _variantdoc_(doc)));
 561
 562     /* IXMLDOMSchemaCollection_add doesn't add a ref on doc */
 563     check_refs(IXMLDOMDocument2, doc, 1);
 564
 565     SysFreeString(str);
 566
 567     V_VT(&v) = VT_INT;
 568     ole_expect(IXMLDOMDocument2_get_schemas(doc, &v), S_FALSE);
 569     ok(V_VT(&v) == VT_NULL, "vt %x\n", V_VT(&v));
 570
 571     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 572     V_VT(&v) = VT_DISPATCH;
 573     V_DISPATCH(&v) = (IDispatch*)cache;
 574
 575     /* check that putref_schemas takes a ref */
 576     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 577     check_refs(IXMLDOMSchemaCollection, cache, 3);
 578
 579     VariantClear(&v); /* refs now 2 */
 580
 581     V_VT(&v) = VT_INT;
 582     /* check that get_schemas adds a ref */
 583     ole_check(IXMLDOMDocument2_get_schemas(doc, &v));
 584     ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
 585     check_refs(IXMLDOMSchemaCollection, cache, 3);
 586
 587     /* get_schemas doesn't release a ref if passed VT_DISPATCH - ie it doesn't call VariantClear() */
 588     ole_check(IXMLDOMDocument2_get_schemas(doc, &v));
 589     ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
 590     check_refs(IXMLDOMSchemaCollection, cache, 4);
 591
 592     /* release the two refs returned by get_schemas */
 593     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 3);
 594     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 2);
 595
 596     /* check that taking another ref on the document doesn't change the schema's ref count */
 597     check_ref_expr(IXMLDOMDocument2_AddRef(doc), 2);
 598     check_refs(IXMLDOMSchemaCollection, cache, 2);
 599     check_ref_expr(IXMLDOMDocument2_Release(doc), 1);
 600
 601     /* call putref_schema with some odd variants */
 602     V_VT(&v) = VT_INT;
 603     ole_expect(IXMLDOMDocument2_putref_schemas(doc, v), E_FAIL);
 604     check_refs(IXMLDOMSchemaCollection, cache, 2);
 605
 606     /* calling with VT_EMPTY releases the schema */
 607     V_VT(&v) = VT_EMPTY;
 608     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 609     check_refs(IXMLDOMSchemaCollection, cache, 1);
 610
 611     /* try setting with VT_UNKNOWN */
 612     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 613     V_VT(&v) = VT_UNKNOWN;
 614     V_UNKNOWN(&v) = (IUnknown*)cache;
 615     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 616     check_refs(IXMLDOMSchemaCollection, cache, 3);
 617
 618     VariantClear(&v); /* refs now 2 */
 619
 620     /* calling with VT_NULL releases the schema */
 621     V_VT(&v) = VT_NULL;
 622     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 623     check_refs(IXMLDOMSchemaCollection, cache, 1);
 624
 625     /* refs now 1 */
 626     /* set again */
 627     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 628     V_VT(&v) = VT_UNKNOWN;
 629     V_UNKNOWN(&v) = (IUnknown*)cache;
 630     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 631     check_refs(IXMLDOMSchemaCollection, cache, 3);
 632
 633     VariantClear(&v); /* refs now 2 */
 634
 635     /* release the final ref on the doc which should release its ref on the schema */
 636     check_ref_expr(IXMLDOMDocument2_Release(doc), 0);
 637
 638     check_refs(IXMLDOMSchemaCollection, cache, 1);
 639     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 0);
 640 }
 641
 642 static void test_collection_refs(void)
 643 {
 644     IXMLDOMDocument2 *schema1, *schema2, *schema3;
 645     IXMLDOMSchemaCollection *cache1, *cache2, *cache3;
 646     VARIANT_BOOL b;
 647     LONG length;
 648
 649     schema1 = create_document(&IID_IXMLDOMDocument2);
 650     schema2 = create_document(&IID_IXMLDOMDocument2);
 651     schema3 = create_document(&IID_IXMLDOMDocument2);
 652
 653     cache1 = create_cache(&IID_IXMLDOMSchemaCollection);
 654     cache2 = create_cache(&IID_IXMLDOMSchemaCollection);
 655     cache3 = create_cache(&IID_IXMLDOMSchemaCollection);
 656
 657     if (!schema1 || !schema2 || !schema3 || !cache1 || !cache2 || !cache3)
 658     {
 659         if (schema1) IXMLDOMDocument2_Release(schema1);
 660         if (schema2) IXMLDOMDocument2_Release(schema2);
 661         if (schema3) IXMLDOMDocument2_Release(schema3);
 662
 663         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 664         if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 665         if (cache3) IXMLDOMSchemaCollection_Release(cache2);
 666
 667         return;
 668     }
 669
 670     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 671     ok(b == VARIANT_TRUE, "failed to load XML\n");
 672
 673     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 674     ok(b == VARIANT_TRUE, "failed to load XML\n");
 675
 676     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 677     ok(b == VARIANT_TRUE, "failed to load XML\n");
 678
 679     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 680     ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 681     ole_check(IXMLDOMSchemaCollection_add(cache3, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 682
 683     check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 684     check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 685     check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 686     schema1 = NULL;
 687     schema2 = NULL;
 688     schema3 = NULL;
 689
 690     /* releasing the original doc does not affect the schema cache */
 691     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 692     ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 693     ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 694
 695     /* we get a read-only domdoc interface, created just for us */
 696     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 697     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 698     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 699
 700     ole_expect(IXMLDOMSchemaCollection_addCollection(cache1, NULL), E_POINTER);
 701     ole_check(IXMLDOMSchemaCollection_addCollection(cache2, cache1));
 702     ole_check(IXMLDOMSchemaCollection_addCollection(cache3, cache2));
 703
 704     length = -1;
 705     ole_check(IXMLDOMSchemaCollection_get_length(cache1, &length));
 706     ok(length == 1, "expected length 1, got %i\n", length);
 707
 708     length = -1;
 709     ole_check(IXMLDOMSchemaCollection_get_length(cache2, &length));
 710     ok(length == 2, "expected length 2, got %i\n", length);
 711
 712     length = -1;
 713     ole_check(IXMLDOMSchemaCollection_get_length(cache3, &length));
 714     ok(length == 3, "expected length 3, got %i\n", length);
 715
 716
 717     /* merging collections does not affect the ref count */
 718     check_refs(IXMLDOMSchemaCollection, cache1, 1);
 719     check_refs(IXMLDOMSchemaCollection, cache2, 1);
 720     check_refs(IXMLDOMSchemaCollection, cache3, 1);
 721
 722     /* nor does it affect the domdoc instances */
 723     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 724     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 725     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 726
 727     if (schema1) check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 728     if (schema2) check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 729     if (schema3) check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 730     schema1 = NULL;
 731     schema2 = NULL;
 732     schema3 = NULL;
 733
 734     /* releasing the domdoc instances doesn't change the cache */
 735     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 736     ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 737     ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 738
 739     /* we can just get them again */
 740     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 741     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 742     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 743
 744     /* releasing the caches does not affect the domdoc instances */
 745     check_ref_expr(IXMLDOMSchemaCollection_Release(cache1), 0);
 746     check_ref_expr(IXMLDOMSchemaCollection_Release(cache2), 0);
 747     check_ref_expr(IXMLDOMSchemaCollection_Release(cache3), 0);
 748
 749     /* they're just for us */
 750     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 751     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 752     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 753
 754     if (schema1) check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 755     if (schema2) check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 756     if (schema3) check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 757
 758     free_bstrs();
 759 }
 760
 761 static void test_length(void)
 762 {
 763     IXMLDOMDocument2 *schema1, *schema2, *schema3;
 764     IXMLDOMSchemaCollection *cache;
 765     VARIANT_BOOL b;
 766     VARIANT v;
 767     LONG length;
 768
 769     schema1 = create_document(&IID_IXMLDOMDocument2);
 770     schema2 = create_document(&IID_IXMLDOMDocument2);
 771     schema3 = create_document(&IID_IXMLDOMDocument2);
 772
 773     cache = create_cache(&IID_IXMLDOMSchemaCollection);
 774
 775     if (!schema1 || !schema2 || !schema3 || !cache)
 776     {
 777         if (schema1) IXMLDOMDocument2_Release(schema1);
 778         if (schema2) IXMLDOMDocument2_Release(schema2);
 779         if (schema3) IXMLDOMDocument2_Release(schema3);
 780
 781         if (cache) IXMLDOMSchemaCollection_Release(cache);
 782
 783         return;
 784     }
 785
 786     VariantInit(&v);
 787
 788     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 789     ok(b == VARIANT_TRUE, "failed to load XML\n");
 790
 791     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 792     ok(b == VARIANT_TRUE, "failed to load XML\n");
 793
 794     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 795     ok(b == VARIANT_TRUE, "failed to load XML\n");
 796
 797     ole_expect(IXMLDOMSchemaCollection_get_length(cache, NULL), E_POINTER);
 798
 799     /* MSDN lies; removing a nonexistent entry produces no error */
 800     ole_check(IXMLDOMSchemaCollection_remove(cache, NULL));
 801     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema1_uri)));
 802
 803     length = -1;
 804     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 805     ok(length == 0, "expected length 0, got %i\n", length);
 806
 807     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 808
 809     length = -1;
 810     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 811     ok(length == 1, "expected length 1, got %i\n", length);
 812
 813     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 814
 815     length = -1;
 816     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 817     ok(length == 2, "expected length 2, got %i\n", length);
 818
 819     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 820
 821     length = -1;
 822     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 823     ok(length == 3, "expected length 3, got %i\n", length);
 824
 825     /* adding with VT_NULL is the same as removing */
 826     V_VT(&v) = VT_NULL;
 827     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), v));
 828
 829     length = -1;
 830     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 831     ok(length == 2, "expected length 2, got %i\n", length);
 832
 833     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema2_uri)));
 834
 835     length = -1;
 836     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 837     ok(length == 1, "expected length 1, got %i\n", length);
 838
 839     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema3_uri)));
 840
 841     length = -1;
 842     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 843     ok(length == 0, "expected length 0, got %i\n", length);
 844
 845     IXMLDOMDocument2_Release(schema1);
 846     IXMLDOMDocument2_Release(schema2);
 847     IXMLDOMDocument2_Release(schema3);
 848     IXMLDOMSchemaCollection_Release(cache);
 849
 850     free_bstrs();
 851 }
 852
 853 static void test_collection_content(void)
 854 {
 855     IXMLDOMDocument2 *schema1, *schema2, *schema3, *schema4, *schema5;
 856     IXMLDOMSchemaCollection *cache1, *cache2;
 857     VARIANT_BOOL b;
 858     BSTR bstr;
 859     BSTR content[5] = {NULL, NULL, NULL, NULL, NULL};
 860     LONG length;
 861     int i, j;
 862
 863     schema1 = create_document_version(30, &IID_IXMLDOMDocument2);
 864     schema2 = create_document_version(30, &IID_IXMLDOMDocument2);
 865     schema3 = create_document_version(30, &IID_IXMLDOMDocument2);
 866
 867     cache1 = create_cache_version(30, &IID_IXMLDOMSchemaCollection);
 868     cache2 = create_cache_version(40, &IID_IXMLDOMSchemaCollection);
 869
 870     if (!schema1 || !schema2 || !schema3 || !cache1)
 871     {
 872         if (schema1) IXMLDOMDocument2_Release(schema1);
 873         if (schema2) IXMLDOMDocument2_Release(schema2);
 874         if (schema3) IXMLDOMDocument2_Release(schema3);
 875
 876         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 877
 878         return;
 879     }
 880
 881     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 882     ok(b == VARIANT_TRUE, "failed to load XML\n");
 883
 884     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 885     ok(b == VARIANT_TRUE, "failed to load XML\n");
 886
 887     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 888     ok(b == VARIANT_TRUE, "failed to load XML\n");
 889
 890     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 891     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 892     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 893
 894     length = -1;
 895     ole_check(IXMLDOMSchemaCollection_get_length(cache1, &length));
 896     ok(length == 3, "expected length 3, got %i\n", length);
 897
 898     IXMLDOMDocument2_Release(schema1);
 899     IXMLDOMDocument2_Release(schema2);
 900     IXMLDOMDocument2_Release(schema3);
 901
 902     if (cache2)
 903     {
 904         schema1 = create_document_version(40, &IID_IXMLDOMDocument2);
 905         schema2 = create_document_version(40, &IID_IXMLDOMDocument2);
 906         schema3 = create_document_version(40, &IID_IXMLDOMDocument2);
 907         schema4 = create_document_version(40, &IID_IXMLDOMDocument2);
 908         schema5 = create_document_version(40, &IID_IXMLDOMDocument2);
 909         ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 910         ok(b == VARIANT_TRUE, "failed to load XML\n");
 911         ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 912         ok(b == VARIANT_TRUE, "failed to load XML\n");
 913         ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xsd_schema1_xml), &b));
 914         ok(b == VARIANT_TRUE, "failed to load XML\n");
 915         ole_check(IXMLDOMDocument2_loadXML(schema4, _bstr_(xsd_schema2_xml), &b));
 916         ok(b == VARIANT_TRUE, "failed to load XML\n");
 917         ole_check(IXMLDOMDocument2_loadXML(schema5, _bstr_(xsd_schema3_xml), &b));
 918         ok(b == VARIANT_TRUE, "failed to load XML\n");
 919
 920         /* combining XDR and XSD schemas in the same cache is fine */
 921         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 922         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 923         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema1_uri), _variantdoc_(schema3)));
 924         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema2_uri), _variantdoc_(schema4)));
 925         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema3_uri), _variantdoc_(schema5)));
 926
 927         length = -1;
 928         ole_check(IXMLDOMSchemaCollection_get_length(cache2, &length));
 929         ok(length == 5, "expected length 5, got %i\n", length);
 930
 931         IXMLDOMDocument2_Release(schema1);
 932         IXMLDOMDocument2_Release(schema2);
 933         IXMLDOMDocument2_Release(schema3);
 934         IXMLDOMDocument2_Release(schema4);
 935         IXMLDOMDocument2_Release(schema5);
 936     }
 937
 938     bstr = NULL;
 939     /* error if index is out of range */
 940     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, &bstr), E_FAIL);
 941     SysFreeString(bstr);
 942     /* error if return pointer is NULL */
 943     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 0, NULL), E_POINTER);
 944     /* pointer is checked first */
 945     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, NULL), E_POINTER);
 946
 947     schema1 = NULL;
 948     /* no error if ns uri does not exist */
 949     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xsd_schema1_uri), (IXMLDOMNode**)&schema1));
 950     ok(!schema1, "expected NULL\n");
 951     /* a NULL bstr corresponds to no-uri ns */
 952     ole_check(IXMLDOMSchemaCollection_get(cache1, NULL, (IXMLDOMNode**)&schema1));
 953     ok(!schema1, "expected NULL\n");
 954     /* error if return pointer is NULL */
 955     ole_expect(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), NULL), E_POINTER);
 956
 957     for (i = 0; i < 3; ++i)
 958     {
 959         bstr = NULL;
 960         ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache1, i, &bstr));
 961         ok(bstr != NULL && *bstr, "expected non-empty string\n");
 962         content[i] = bstr;
 963
 964         for (j = 0; j < i; ++j)
 965             ok(winetest_strcmpW(content[j], bstr), "got duplicate entry\n");
 966     }
 967
 968     for (i = 0; i < 3; ++i)
 969     {
 970         SysFreeString(content[i]);
 971         content[i] = NULL;
 972     }
 973
 974     if (cache2)
 975     {
 976         for (i = 0; i < 5; ++i)
 977         {
 978             bstr = NULL;
 979             ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache2, i, &bstr));
 980             ok(bstr != NULL && *bstr, "expected non-empty string\n");
 981
 982             for (j = 0; j < i; ++j)
 983                 ok(winetest_strcmpW(content[j], bstr), "got duplicate entry\n");
 984             content[i] = bstr;
 985         }
 986
 987         for (i = 0; i < 5; ++i)
 988         {
 989             SysFreeString(content[i]);
 990             content[i] = NULL;
 991         }
 992     }
 993
 994     IXMLDOMSchemaCollection_Release(cache1);
 995     if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 996
 997     free_bstrs();
 998 }
 999
1000 static void test_XDR_schemas(void)
1001 {
1002     IXMLDOMDocument2 *doc, *schema;
1003     IXMLDOMSchemaCollection* cache;
1004     IXMLDOMParseError* err;
1005     VARIANT_BOOL b;
1006     VARIANT v;
1007     BSTR bstr;
1008
1009     doc = create_document(&IID_IXMLDOMDocument2);
1010     schema = create_document(&IID_IXMLDOMDocument2);
1011     cache = create_cache(&IID_IXMLDOMSchemaCollection);
1012
1013     if (!doc || !schema || !cache)
1014     {
1015         if (doc)    IXMLDOMDocument2_Release(doc);
1016         if (schema) IXMLDOMDocument2_Release(schema);
1017         if (cache)  IXMLDOMSchemaCollection_Release(cache);
1018
1019         return;
1020     }
1021
1022     VariantInit(&v);
1023
1024     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML1), &b));
1025     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1026
1027     ole_check(IXMLDOMDocument2_loadXML(schema, _bstr_(szOpenSeqXDR), &b));
1028     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1029
1030     /* load the schema */
1031     V_VT(&v) = VT_DISPATCH;
1032     V_DISPATCH(&v) = NULL;
1033     ole_check(IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1034     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1035     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(""), v));
1036     VariantClear(&v);
1037
1038     /* associate the cache to the doc */
1039     V_VT(&v) = VT_DISPATCH;
1040     V_DISPATCH(&v) = NULL;
1041     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1042     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1043     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1044     VariantClear(&v);
1045
1046     /* validate the doc
1047      * only declared elements in the declared order
1048      * this is fine */
1049     err = NULL;
1050     bstr = NULL;
1051     ole_check(IXMLDOMDocument2_validate(doc, &err));
1052     ok(err != NULL, "domdoc_validate() should always set err\n");
1053     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
1054     ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
1055     SysFreeString(bstr);
1056     IXMLDOMParseError_Release(err);
1057
1058     /* load the next doc */
1059     IXMLDOMDocument2_Release(doc);
1060     doc = create_document(&IID_IXMLDOMDocument2);
1061     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML2), &b));
1062     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1063
1064     /* associate the cache to the doc */
1065     V_VT(&v) = VT_DISPATCH;
1066     V_DISPATCH(&v) = NULL;
1067     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1068     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1069     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1070     VariantClear(&v);
1071
1072     /* validate the doc
1073      * declared elements in the declared order, with an extra declared element at the end
1074      * this is fine */
1075     err = NULL;
1076     bstr = NULL;
1077     ole_check(IXMLDOMDocument2_validate(doc, &err));
1078     ok(err != NULL, "domdoc_validate() should always set err\n");
1079     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
1080     ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
1081     SysFreeString(bstr);
1082     IXMLDOMParseError_Release(err);
1083
1084     /* load the next doc */
1085     IXMLDOMDocument2_Release(doc);
1086     doc = create_document(&IID_IXMLDOMDocument2);
1087     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML3), &b));
1088     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1089
1090     /* associate the cache to the doc */
1091     V_VT(&v) = VT_DISPATCH;
1092     V_DISPATCH(&v) = NULL;
1093     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1094     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1095     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1096     VariantClear(&v);
1097
1098     /* validate the doc
1099      * fails, extra elements are only allowed at the end */
1100     err = NULL;
1101     bstr = NULL;
1102     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
1103     ok(err != NULL, "domdoc_validate() should always set err\n");
1104     todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
1105     SysFreeString(bstr);
1106     IXMLDOMParseError_Release(err);
1107
1108     /* load the next doc */
1109     IXMLDOMDocument2_Release(doc);
1110     doc = create_document(&IID_IXMLDOMDocument2);
1111     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML4), &b));
1112     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1113
1114     /* associate the cache to the doc */
1115     V_VT(&v) = VT_DISPATCH;
1116     V_DISPATCH(&v) = NULL;
1117     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1118     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1119     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1120     VariantClear(&v);
1121
1122     /* validate the doc
1123      * fails, undeclared elements are not allowed */
1124     err = NULL;
1125     bstr = NULL;
1126     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
1127     ok(err != NULL, "domdoc_validate() should always set err\n");
1128     todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
1129     SysFreeString(bstr);
1130     IXMLDOMParseError_Release(err);
1131
1132     IXMLDOMDocument2_Release(doc);
1133     IXMLDOMDocument2_Release(schema);
1134     IXMLDOMSchemaCollection_Release(cache);
1135
1136     free_bstrs();
1137 }
1138
1139 static void test_XDR_datatypes(void)
1140 {
1141     IXMLDOMDocument2 *doc, *schema;
1142     IXMLDOMSchemaCollection* cache;
1143     IXMLDOMNode* node;
1144     IXMLDOMParseError* err;
1145     VARIANT_BOOL b;
1146     VARIANT v, vtmp;
1147     LONG l;
1148     BSTR bstr;
1149
1150     VariantInit(&v);
1151
1152     doc = create_document(&IID_IXMLDOMDocument2);
1153     schema = create_document(&IID_IXMLDOMDocument2);
1154     cache = create_cache(&IID_IXMLDOMSchemaCollection);
1155
1156     if (!doc || !schema || !cache)
1157     {
1158         if (doc)    IXMLDOMDocument2_Release(doc);
1159         if (schema) IXMLDOMDocument2_Release(schema);
1160         if (cache)  IXMLDOMSchemaCollection_Release(cache);
1161
1162         return;
1163     }
1164
1165     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szDatatypeXML), &b));
1166     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1167
1168     ole_check(IXMLDOMDocument2_loadXML(schema, _bstr_(szDatatypeXDR), &b));
1169     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1170
1171     err = NULL;
1172     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
1173     ok(err != NULL, "domdoc_validate() should always set err\n");
1174     ole_check(IXMLDOMParseError_get_errorCode(err, &l));
1175     ok(l == E_XML_NODTD, "got %08x\n", l);
1176     IXMLDOMParseError_Release(err);
1177
1178     /* check data types without the schema */
1179     node = NULL;
1180     memset(&vtmp, -1, sizeof(VARIANT));
1181     V_VT(&vtmp) = VT_NULL;
1182     V_BSTR(&vtmp) = NULL;
1183     memset(&v, -1, sizeof(VARIANT));
1184     V_VT(&v) = VT_EMPTY;
1185     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBase64']/Value/base64Data"), &node));
1186     ok(node != NULL, "expected node\n");
1187     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1188     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1189     /* when returning VT_NULL, the pointer is set to NULL */
1190     ok(memcmp(&v, &vtmp, sizeof(VARIANT)) == 0, "got %p\n", V_BSTR(&v));
1191     if (V_VT(&v) == VT_BSTR)
1192         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1193     VariantClear(&v);
1194     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1195     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1196     VariantClear(&v);
1197     IXMLDOMNode_Release(node);
1198
1199     node = NULL;
1200     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testHex']/Value/hexData"), &node));
1201     ok(node != NULL, "expected node\n");
1202     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1203     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1204     if (V_VT(&v) == VT_BSTR)
1205         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1206     VariantClear(&v);
1207     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1208     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1209     VariantClear(&v);
1210     IXMLDOMNode_Release(node);
1211
1212     node = NULL;
1213     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBool']/Value/boolData"), &node));
1214     ok(node != NULL, "expected node\n");
1215     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1216     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1217     if (V_VT(&v) == VT_BSTR)
1218         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1219     VariantClear(&v);
1220     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1221     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1222     VariantClear(&v);
1223     IXMLDOMNode_Release(node);
1224
1225     node = NULL;
1226     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testChar']/Value/charData"), &node));
1227     ok(node != NULL, "expected node\n");
1228     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1229     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1230     if (V_VT(&v) == VT_BSTR)
1231         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1232     VariantClear(&v);
1233     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1234     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1235     VariantClear(&v);
1236     IXMLDOMNode_Release(node);
1237
1238     node = NULL;
1239     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDate']/Value/dateData"), &node));
1240     ok(node != NULL, "expected node\n");
1241     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1242     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1243     if (V_VT(&v) == VT_BSTR)
1244         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1245     VariantClear(&v);
1246     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1247     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1248     VariantClear(&v);
1249     IXMLDOMNode_Release(node);
1250
1251     node = NULL;
1252     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTime']/Value/dateTimeData"), &node));
1253     ok(node != NULL, "expected node\n");
1254     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1255     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1256     if (V_VT(&v) == VT_BSTR)
1257         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1258     VariantClear(&v);
1259     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1260     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1261     VariantClear(&v);
1262     IXMLDOMNode_Release(node);
1263
1264     node = NULL;
1265     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTimeTz']/Value/dateTimeTzData"), &node));
1266     ok(node != NULL, "expected node\n");
1267     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1268     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1269     if (V_VT(&v) == VT_BSTR)
1270         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1271     VariantClear(&v);
1272     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1273     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1274     VariantClear(&v);
1275     IXMLDOMNode_Release(node);
1276
1277     node = NULL;
1278     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFixed']/Value/fixedData"), &node));
1279     ok(node != NULL, "expected node\n");
1280     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1281     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1282     if (V_VT(&v) == VT_BSTR)
1283         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1284     VariantClear(&v);
1285     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1286     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1287     VariantClear(&v);
1288     IXMLDOMNode_Release(node);
1289
1290     node = NULL;
1291     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFloat']/Value/floatData"), &node));
1292     ok(node != NULL, "expected node\n");
1293     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1294     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1295     if (V_VT(&v) == VT_BSTR)
1296         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1297     VariantClear(&v);
1298     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1299     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1300     VariantClear(&v);
1301     IXMLDOMNode_Release(node);
1302
1303     node = NULL;
1304     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI1']/Value/i1Data"), &node));
1305     ok(node != NULL, "expected node\n");
1306     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1307     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1308     if (V_VT(&v) == VT_BSTR)
1309         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1310     VariantClear(&v);
1311     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1312     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1313     VariantClear(&v);
1314     IXMLDOMNode_Release(node);
1315
1316     node = NULL;
1317     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI2']/Value/i2Data"), &node));
1318     ok(node != NULL, "expected node\n");
1319     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1320     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1321     if (V_VT(&v) == VT_BSTR)
1322         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1323     VariantClear(&v);
1324     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1325     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1326     VariantClear(&v);
1327     IXMLDOMNode_Release(node);
1328
1329     node = NULL;
1330     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI4']/Value/i4Data"), &node));
1331     ok(node != NULL, "expected node\n");
1332     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1333     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1334     if (V_VT(&v) == VT_BSTR)
1335         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1336     VariantClear(&v);
1337     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1338     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1339     VariantClear(&v);
1340     IXMLDOMNode_Release(node);
1341
1342     node = NULL;
1343     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI8']/Value/i8Data"), &node));
1344     ok(node != NULL, "expected node\n");
1345     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1346     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1347     if (V_VT(&v) == VT_BSTR)
1348         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1349     VariantClear(&v);
1350     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1351     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1352     VariantClear(&v);
1353     IXMLDOMNode_Release(node);
1354
1355     node = NULL;
1356     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testInt']/Value/intData"), &node));
1357     ok(node != NULL, "expected node\n");
1358     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1359     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1360     if (V_VT(&v) == VT_BSTR)
1361         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1362     VariantClear(&v);
1363     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1364     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1365     VariantClear(&v);
1366     IXMLDOMNode_Release(node);
1367
1368     node = NULL;
1369     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtoken']/Value/nmtokData"), &node));
1370     ok(node != NULL, "expected node\n");
1371     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1372     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1373     if (V_VT(&v) == VT_BSTR)
1374         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1375     VariantClear(&v);
1376     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1377     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1378     VariantClear(&v);
1379     IXMLDOMNode_Release(node);
1380
1381     node = NULL;
1382     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtokens']/Value/nmtoksData"), &node));
1383     ok(node != NULL, "expected node\n");
1384     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1385     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1386     if (V_VT(&v) == VT_BSTR)
1387         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1388     VariantClear(&v);
1389     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1390     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1391     VariantClear(&v);
1392     IXMLDOMNode_Release(node);
1393
1394     node = NULL;
1395     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNumber']/Value/numData"), &node));
1396     ok(node != NULL, "expected node\n");
1397     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1398     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1399     if (V_VT(&v) == VT_BSTR)
1400         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1401     VariantClear(&v);
1402     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1403     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1404     VariantClear(&v);
1405     IXMLDOMNode_Release(node);
1406
1407     node = NULL;
1408     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR4']/Value/r4Data"), &node));
1409     ok(node != NULL, "expected node\n");
1410     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1411     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1412     if (V_VT(&v) == VT_BSTR)
1413         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1414     VariantClear(&v);
1415     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1416     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1417     VariantClear(&v);
1418     IXMLDOMNode_Release(node);
1419
1420     node = NULL;
1421     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR8']/Value/r8Data"), &node));
1422     ok(node != NULL, "expected node\n");
1423     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1424     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1425     if (V_VT(&v) == VT_BSTR)
1426         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1427     VariantClear(&v);
1428     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1429     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1430     VariantClear(&v);
1431     IXMLDOMNode_Release(node);
1432
1433     node = NULL;
1434     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testString']/Value/stringData"), &node));
1435     ok(node != NULL, "expected node\n");
1436     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1437     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1438     if (V_VT(&v) == VT_BSTR)
1439         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1440     VariantClear(&v);
1441     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1442     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1443     VariantClear(&v);
1444     IXMLDOMNode_Release(node);
1445
1446     node = NULL;
1447     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTime']/Value/timeData"), &node));
1448     ok(node != NULL, "expected node\n");
1449     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1450     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1451     if (V_VT(&v) == VT_BSTR)
1452         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1453     VariantClear(&v);
1454     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1455     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1456     VariantClear(&v);
1457     IXMLDOMNode_Release(node);
1458
1459     node = NULL;
1460     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTimeTz']/Value/timeTzData"), &node));
1461     ok(node != NULL, "expected node\n");
1462     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1463     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1464     if (V_VT(&v) == VT_BSTR)
1465         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1466     VariantClear(&v);
1467     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1468     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1469     VariantClear(&v);
1470     IXMLDOMNode_Release(node);
1471
1472     node = NULL;
1473     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU1']/Value/u1Data"), &node));
1474     ok(node != NULL, "expected node\n");
1475     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1476     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1477     if (V_VT(&v) == VT_BSTR)
1478         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1479     VariantClear(&v);
1480     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1481     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1482     VariantClear(&v);
1483     IXMLDOMNode_Release(node);
1484
1485     node = NULL;
1486     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU2']/Value/u2Data"), &node));
1487     ok(node != NULL, "expected node\n");
1488     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1489     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1490     if (V_VT(&v) == VT_BSTR)
1491         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1492     VariantClear(&v);
1493     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1494     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1495     VariantClear(&v);
1496     IXMLDOMNode_Release(node);
1497
1498     node = NULL;
1499     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU4']/Value/u4Data"), &node));
1500     ok(node != NULL, "expected node\n");
1501     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1502     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1503     if (V_VT(&v) == VT_BSTR)
1504         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1505     VariantClear(&v);
1506     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1507     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1508     VariantClear(&v);
1509     IXMLDOMNode_Release(node);
1510
1511     node = NULL;
1512     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU8']/Value/u8Data"), &node));
1513     ok(node != NULL, "expected node\n");
1514     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1515     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1516     if (V_VT(&v) == VT_BSTR)
1517         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1518     VariantClear(&v);
1519     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1520     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1521     VariantClear(&v);
1522     IXMLDOMNode_Release(node);
1523
1524     node = NULL;
1525     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testURI']/Value/uriData"), &node));
1526     ok(node != NULL, "expected node\n");
1527     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1528     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1529     if (V_VT(&v) == VT_BSTR)
1530         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1531     VariantClear(&v);
1532     IXMLDOMNode_Release(node);
1533
1534     node = NULL;
1535     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testUUID']/Value/uuidData"), &node));
1536     ok(node != NULL, "expected node\n");
1537     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1538     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1539     if (V_VT(&v) == VT_BSTR)
1540         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1541     VariantClear(&v);
1542     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1543     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1544     VariantClear(&v);
1545     IXMLDOMNode_Release(node);
1546
1547     /* now load the schema */
1548     V_VT(&v) = VT_DISPATCH;
1549     V_DISPATCH(&v) = NULL;
1550     ole_check(IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1551     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1552     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_("urn:x-schema:datatype-test-xdr"), v));
1553     VariantClear(&v);
1554
1555     /* associate the cache to the doc */
1556     V_VT(&v) = VT_DISPATCH;
1557     V_DISPATCH(&v) = NULL;
1558     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1559     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1560     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1561     VariantClear(&v);
1562
1563     /* validate the doc */
1564     err = NULL;
1565     l = 0;
1566     bstr = NULL;
1567     ole_check(IXMLDOMDocument2_validate(doc, &err));
1568     ok(err != NULL, "domdoc_validate() should always set err\n");
1569     ole_expect(IXMLDOMParseError_get_errorCode(err, &l), S_FALSE);
1570     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
1571     ok(l == 0, "got %08x : %s\n", l, wine_dbgstr_w(bstr));
1572     SysFreeString(bstr);
1573     IXMLDOMParseError_Release(err);
1574
1575     /* check the data types again */
1576     node = NULL;
1577     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBase64']/Value/base64Data"), &node));
1578     ok(node != NULL, "expected node\n");
1579     ole_check(IXMLDOMNode_get_dataType(node, &v));
1580     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1581     if (V_VT(&v) == VT_BSTR)
1582         ok(lstrcmpW(V_BSTR(&v), _bstr_("bin.base64")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1583     VariantClear(&v);
1584     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1585     ok(V_VT(&v) == (VT_ARRAY|VT_UI1), "got variant type %i\n", V_VT(&v));
1586     VariantClear(&v);
1587     IXMLDOMNode_Release(node);
1588
1589     node = NULL;
1590     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testHex']/Value/hexData"), &node));
1591     ok(node != NULL, "expected node\n");
1592     ole_check(IXMLDOMNode_get_dataType(node, &v));
1593     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1594     if (V_VT(&v) == VT_BSTR)
1595         ok(lstrcmpW(V_BSTR(&v), _bstr_("bin.hex")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1596     VariantClear(&v);
1597     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1598     ok(V_VT(&v) == (VT_ARRAY|VT_UI1), "got variant type %i\n", V_VT(&v));
1599     VariantClear(&v);
1600     IXMLDOMNode_Release(node);
1601
1602     node = NULL;
1603     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBool']/Value/boolData"), &node));
1604     ok(node != NULL, "expected node\n");
1605     ole_check(IXMLDOMNode_get_dataType(node, &v));
1606     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1607     if (V_VT(&v) == VT_BSTR)
1608         ok(lstrcmpW(V_BSTR(&v), _bstr_("boolean")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1609     VariantClear(&v);
1610     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1611     ok(V_VT(&v) == VT_BOOL, "got variant type %i\n", V_VT(&v));
1612     if (V_VT(&v) == VT_BOOL)
1613         ok(V_BOOL(&v) == VARIANT_TRUE, "got %04x\n", V_BOOL(&v));
1614     VariantClear(&v);
1615     IXMLDOMNode_Release(node);
1616
1617     node = NULL;
1618     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testChar']/Value/charData"), &node));
1619     ok(node != NULL, "expected node\n");
1620     ole_check(IXMLDOMNode_get_dataType(node, &v));
1621     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1622     if (V_VT(&v) == VT_BSTR)
1623         ok(lstrcmpW(V_BSTR(&v), _bstr_("char")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1624     VariantClear(&v);
1625     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1626     todo_wine ok(V_VT(&v) == VT_I4, "got variant type %i\n", V_VT(&v));
1627     if (V_VT(&v) == VT_I4)
1628         ok(V_I4(&v) == 'u', "got %08x\n", V_I4(&v));
1629     VariantClear(&v);
1630     IXMLDOMNode_Release(node);
1631
1632     node = NULL;
1633     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDate']/Value/dateData"), &node));
1634     ok(node != NULL, "expected node\n");
1635     ole_check(IXMLDOMNode_get_dataType(node, &v));
1636     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1637     if (V_VT(&v) == VT_BSTR)
1638         ok(lstrcmpW(V_BSTR(&v), _bstr_("date")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1639     VariantClear(&v);
1640     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1641     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1642     VariantClear(&v);
1643     IXMLDOMNode_Release(node);
1644
1645     node = NULL;
1646     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTime']/Value/dateTimeData"), &node));
1647     ok(node != NULL, "expected node\n");
1648     ole_check(IXMLDOMNode_get_dataType(node, &v));
1649     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1650     if (V_VT(&v) == VT_BSTR)
1651         ok(lstrcmpW(V_BSTR(&v), _bstr_("dateTime")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1652     VariantClear(&v);
1653     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1654     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1655     VariantClear(&v);
1656     IXMLDOMNode_Release(node);
1657
1658     node = NULL;
1659     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTimeTz']/Value/dateTimeTzData"), &node));
1660     ok(node != NULL, "expected node\n");
1661     ole_check(IXMLDOMNode_get_dataType(node, &v));
1662     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1663     if (V_VT(&v) == VT_BSTR)
1664         ok(lstrcmpW(V_BSTR(&v), _bstr_("dateTime.tz")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1665     VariantClear(&v);
1666     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1667     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1668     VariantClear(&v);
1669     IXMLDOMNode_Release(node);
1670
1671     node = NULL;
1672     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFixed']/Value/fixedData"), &node));
1673     ok(node != NULL, "expected node\n");
1674     ole_check(IXMLDOMNode_get_dataType(node, &v));
1675     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1676     if (V_VT(&v) == VT_BSTR)
1677         ok(lstrcmpW(V_BSTR(&v), _bstr_("fixed.14.4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1678     VariantClear(&v);
1679     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1680     ok(V_VT(&v) == VT_CY, "got variant type %i\n", V_VT(&v));
1681     VariantClear(&v);
1682     IXMLDOMNode_Release(node);
1683
1684     node = NULL;
1685     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFloat']/Value/floatData"), &node));
1686     ok(node != NULL, "expected node\n");
1687     ole_check(IXMLDOMNode_get_dataType(node, &v));
1688     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1689     if (V_VT(&v) == VT_BSTR)
1690         ok(lstrcmpW(V_BSTR(&v), _bstr_("float")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1691     VariantClear(&v);
1692     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1693     ok(V_VT(&v) == VT_R8, "got variant type %i\n", V_VT(&v));
1694     if (V_VT(&v) == VT_R8)
1695         ok(V_R8(&v) == (double)3.14159, "got %f\n", V_R8(&v));
1696     VariantClear(&v);
1697     IXMLDOMNode_Release(node);
1698
1699     node = NULL;
1700     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI1']/Value/i1Data"), &node));
1701     ok(node != NULL, "expected node\n");
1702     ole_check(IXMLDOMNode_get_dataType(node, &v));
1703     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1704     if (V_VT(&v) == VT_BSTR)
1705         ok(lstrcmpW(V_BSTR(&v), _bstr_("i1")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1706     VariantClear(&v);
1707     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1708     ok(V_VT(&v) == VT_I1, "got variant type %i\n", V_VT(&v));
1709     if (V_VT(&v) == VT_I1)
1710         ok(V_I1(&v) == 42, "got %i\n", V_I1(&v));
1711     VariantClear(&v);
1712     IXMLDOMNode_Release(node);
1713
1714     node = NULL;
1715     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI2']/Value/i2Data"), &node));
1716     ok(node != NULL, "expected node\n");
1717     ole_check(IXMLDOMNode_get_dataType(node, &v));
1718     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1719     if (V_VT(&v) == VT_BSTR)
1720         ok(lstrcmpW(V_BSTR(&v), _bstr_("i2")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1721     VariantClear(&v);
1722     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1723     ok(V_VT(&v) == VT_I2, "got variant type %i\n", V_VT(&v));
1724     if (V_VT(&v) == VT_I2)
1725         ok(V_I2(&v) == 420, "got %i\n", V_I2(&v));
1726     VariantClear(&v);
1727     IXMLDOMNode_Release(node);
1728
1729     node = NULL;
1730     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI4']/Value/i4Data"), &node));
1731     ok(node != NULL, "expected node\n");
1732     ole_check(IXMLDOMNode_get_dataType(node, &v));
1733     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1734     if (V_VT(&v) == VT_BSTR)
1735         ok(lstrcmpW(V_BSTR(&v), _bstr_("i4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1736     VariantClear(&v);
1737     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1738     ok(V_VT(&v) == VT_I4, "got variant type %i\n", V_VT(&v));
1739     if (V_VT(&v) == VT_I4)
1740         ok(V_I4(&v) == -420000000, "got %i\n", V_I4(&v));
1741     VariantClear(&v);
1742     IXMLDOMNode_Release(node);
1743
1744     node = NULL;
1745     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI8']/Value/i8Data"), &node));
1746     ok(node != NULL, "expected node\n");
1747     ole_check(IXMLDOMNode_get_dataType(node, &v));
1748     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1749     if (V_VT(&v) == VT_BSTR)
1750         ok(lstrcmpW(V_BSTR(&v), _bstr_("i8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1751     VariantClear(&v);
1752     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1753     /* TODO: which platforms return VT_I8? */
1754     todo_wine ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1755     if (V_VT(&v) == VT_I8)
1756         expect_int64(V_I8(&v), -4200000000, 10);
1757     VariantClear(&v);
1758     IXMLDOMNode_Release(node);
1759
1760     node = NULL;
1761     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testInt']/Value/intData"), &node));
1762     ok(node != NULL, "expected node\n");
1763     ole_check(IXMLDOMNode_get_dataType(node, &v));
1764     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1765     if (V_VT(&v) == VT_BSTR)
1766         ok(lstrcmpW(V_BSTR(&v), _bstr_("int")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1767     VariantClear(&v);
1768     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1769     ok(V_VT(&v) == VT_I4, "got variant type %i\n", V_VT(&v));
1770     if (V_VT(&v) == VT_I4)
1771         ok(V_I4(&v) == 42, "got %i\n", V_I4(&v));
1772     VariantClear(&v);
1773     IXMLDOMNode_Release(node);
1774
1775     /* nmtoken does not return a bstr for get_dataType() */
1776     node = NULL;
1777     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtoken']/Value/nmtokData"), &node));
1778     ok(node != NULL, "expected node\n");
1779     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1780     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1781     if (V_VT(&v) == VT_BSTR)
1782         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1783     VariantClear(&v);
1784     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1785     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1786     VariantClear(&v);
1787     IXMLDOMNode_Release(node);
1788
1789     /* nmtokens does not return a bstr for get_dataType() */
1790     node = NULL;
1791     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtokens']/Value/nmtoksData"), &node));
1792     ok(node != NULL, "expected node\n");
1793     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1794     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1795     if (V_VT(&v) == VT_BSTR)
1796         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1797     VariantClear(&v);
1798     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1799     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1800     VariantClear(&v);
1801     IXMLDOMNode_Release(node);
1802
1803     node = NULL;
1804     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNumber']/Value/numData"), &node));
1805     ok(node != NULL, "expected node\n");
1806     ole_check(IXMLDOMNode_get_dataType(node, &v));
1807     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1808     if (V_VT(&v) == VT_BSTR)
1809         ok(lstrcmpW(V_BSTR(&v), _bstr_("number")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1810     VariantClear(&v);
1811     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1812     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1813     VariantClear(&v);
1814     IXMLDOMNode_Release(node);
1815
1816     node = NULL;
1817     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR4']/Value/r4Data"), &node));
1818     ok(node != NULL, "expected node\n");
1819     ole_check(IXMLDOMNode_get_dataType(node, &v));
1820     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1821     if (V_VT(&v) == VT_BSTR)
1822         ok(lstrcmpW(V_BSTR(&v), _bstr_("r4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1823     VariantClear(&v);
1824     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1825     ok(V_VT(&v) == VT_R4, "got variant type %i\n", V_VT(&v));
1826     if (V_VT(&v) == VT_R4)
1827         ok(V_R4(&v) == (float)3.14159265, "got %f\n", V_R4(&v));
1828     VariantClear(&v);
1829     IXMLDOMNode_Release(node);
1830
1831     node = NULL;
1832     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR8']/Value/r8Data"), &node));
1833     ok(node != NULL, "expected node\n");
1834     ole_check(IXMLDOMNode_get_dataType(node, &v));
1835     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1836     if (V_VT(&v) == VT_BSTR)
1837         ok(lstrcmpW(V_BSTR(&v), _bstr_("r8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1838     VariantClear(&v);
1839     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1840     ok(V_VT(&v) == VT_R8, "got variant type %i\n", V_VT(&v));
1841     if (V_VT(&v) == VT_R8)
1842         todo_wine ok(V_R8(&v) == (double)3.14159265358979323846, "got %.20f\n", V_R8(&v));
1843     VariantClear(&v);
1844     IXMLDOMNode_Release(node);
1845
1846     /* dt:string is the default, does not return a bstr for get_dataType() */
1847     node = NULL;
1848     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testString']/Value/stringData"), &node));
1849     ok(node != NULL, "expected node\n");
1850     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1851     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1852     if (V_VT(&v) == VT_BSTR)
1853         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1854     VariantClear(&v);
1855     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1856     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1857     VariantClear(&v);
1858     IXMLDOMNode_Release(node);
1859
1860     node = NULL;
1861     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTime']/Value/timeData"), &node));
1862     ok(node != NULL, "expected node\n");
1863     ole_check(IXMLDOMNode_get_dataType(node, &v));
1864     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1865     if (V_VT(&v) == VT_BSTR)
1866         ok(lstrcmpW(V_BSTR(&v), _bstr_("time")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1867     VariantClear(&v);
1868     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1869     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1870     VariantClear(&v);
1871     IXMLDOMNode_Release(node);
1872
1873     node = NULL;
1874     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTimeTz']/Value/timeTzData"), &node));
1875     ok(node != NULL, "expected node\n");
1876     ole_check(IXMLDOMNode_get_dataType(node, &v));
1877     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1878     if (V_VT(&v) == VT_BSTR)
1879         ok(lstrcmpW(V_BSTR(&v), _bstr_("time.tz")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1880     VariantClear(&v);
1881     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1882     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1883     VariantClear(&v);
1884     IXMLDOMNode_Release(node);
1885
1886     node = NULL;
1887     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU1']/Value/u1Data"), &node));
1888     ok(node != NULL, "expected node\n");
1889     ole_check(IXMLDOMNode_get_dataType(node, &v));
1890     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1891     if (V_VT(&v) == VT_BSTR)
1892         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui1")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1893     VariantClear(&v);
1894     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1895     ok(V_VT(&v) == VT_UI1, "got variant type %i\n", V_VT(&v));
1896     if (V_VT(&v) == VT_UI1)
1897         ok(V_UI1(&v) == 0xFF, "got %02x\n", V_UI1(&v));
1898     VariantClear(&v);
1899     IXMLDOMNode_Release(node);
1900
1901     node = NULL;
1902     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU2']/Value/u2Data"), &node));
1903     ok(node != NULL, "expected node\n");
1904     ole_check(IXMLDOMNode_get_dataType(node, &v));
1905     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1906     if (V_VT(&v) == VT_BSTR)
1907         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui2")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1908     VariantClear(&v);
1909     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1910     ok(V_VT(&v) == VT_UI2, "got variant type %i\n", V_VT(&v));
1911     if (V_VT(&v) == VT_UI2)
1912         ok(V_UI2(&v) == 0xFFFF, "got %04x\n", V_UI2(&v));
1913     VariantClear(&v);
1914     IXMLDOMNode_Release(node);
1915
1916     node = NULL;
1917     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU4']/Value/u4Data"), &node));
1918     ok(node != NULL, "expected node\n");
1919     ole_check(IXMLDOMNode_get_dataType(node, &v));
1920     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1921     if (V_VT(&v) == VT_BSTR)
1922         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1923     VariantClear(&v);
1924     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1925     ok(V_VT(&v) == VT_UI4, "got variant type %i\n", V_VT(&v));
1926     if (V_VT(&v) == VT_UI4)
1927         ok(V_UI4(&v) == 0xFFFFFFFF, "got %08x\n", V_UI4(&v));
1928     VariantClear(&v);
1929     IXMLDOMNode_Release(node);
1930
1931     node = NULL;
1932     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU8']/Value/u8Data"), &node));
1933     ok(node != NULL, "expected node\n");
1934     ole_check(IXMLDOMNode_get_dataType(node, &v));
1935     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1936     if (V_VT(&v) == VT_BSTR)
1937         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1938     VariantClear(&v);
1939     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1940     /* TODO: which platforms return VT_UI8? */
1941     todo_wine ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1942     if (V_VT(&v) == VT_UI8)
1943         expect_uint64(V_UI8(&v), 0xFFFFFFFFFFFFFFFF, 16);
1944     VariantClear(&v);
1945     IXMLDOMNode_Release(node);
1946
1947     node = NULL;
1948     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testURI']/Value/uriData"), &node));
1949     ok(node != NULL, "expected node\n");
1950     ole_check(IXMLDOMNode_get_dataType(node, &v));
1951     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1952     if (V_VT(&v) == VT_BSTR)
1953         ok(lstrcmpW(V_BSTR(&v), _bstr_("uri")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1954     VariantClear(&v);
1955     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1956     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1957     VariantClear(&v);
1958     IXMLDOMNode_Release(node);
1959
1960     node = NULL;
1961     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testUUID']/Value/uuidData"), &node));
1962     ok(node != NULL, "expected node\n");
1963     ole_check(IXMLDOMNode_get_dataType(node, &v));
1964     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1965     if (V_VT(&v) == VT_BSTR)
1966         ok(lstrcmpW(V_BSTR(&v), _bstr_("uuid")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1967     VariantClear(&v);
1968     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1969     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1970     VariantClear(&v);
1971     IXMLDOMNode_Release(node);
1972
1973     ok(IXMLDOMDocument2_Release(schema) == 0, "schema not released\n");
1974     ok(IXMLDOMDocument2_Release(doc) == 0, "doc not released\n");
1975     ok(IXMLDOMSchemaCollection_Release(cache) == 0, "cache not released\n");
1976
1977     free_bstrs();
1978 }
1979
1980 static void test_validate_on_load(void)
1981 {
1982     IXMLDOMSchemaCollection2 *cache;
1983     VARIANT_BOOL b;
1984     HRESULT hr;
1985
1986     cache = create_cache_version(40, &IID_IXMLDOMSchemaCollection2);
1987     if (!cache) return;
1988
1989     hr = IXMLDOMSchemaCollection2_get_validateOnLoad(cache, NULL);
1990     EXPECT_HR(hr, E_POINTER);
1991
1992     b = VARIANT_FALSE;
1993     hr = IXMLDOMSchemaCollection2_get_validateOnLoad(cache, &b);
1994     EXPECT_HR(hr, S_OK);
1995     ok(b == VARIANT_TRUE, "got %d\n", b);
1996
1997     IXMLDOMSchemaCollection2_Release(cache);
1998 }
1999
2000 static void test_obj_dispex(IUnknown *obj)
2001 {
2002     static const WCHAR starW[] = {'*',0};
2003     DISPID dispid = DISPID_SAX_XMLREADER_GETFEATURE;
2004     IDispatchEx *dispex;
2005     IUnknown *unk;
2006     DWORD props;
2007     UINT ticnt;
2008     HRESULT hr;
2009     BSTR name;
2010
2011     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2012     EXPECT_HR(hr, S_OK);
2013     if (FAILED(hr)) return;
2014
2015     ticnt = 0;
2016     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
2017     EXPECT_HR(hr, S_OK);
2018     ok(ticnt == 1, "ticnt=%u\n", ticnt);
2019
2020     name = SysAllocString(starW);
2021     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
2022     EXPECT_HR(hr, E_NOTIMPL);
2023     SysFreeString(name);
2024
2025     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
2026     EXPECT_HR(hr, E_NOTIMPL);
2027
2028     props = 0;
2029     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
2030     EXPECT_HR(hr, E_NOTIMPL);
2031     ok(props == 0, "expected 0 got %d\n", props);
2032
2033     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
2034     EXPECT_HR(hr, E_NOTIMPL);
2035     if (SUCCEEDED(hr)) SysFreeString(name);
2036
2037     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_SCHEMACOLLECTION_ADD, &dispid);
2038     EXPECT_HR(hr, E_NOTIMPL);
2039
2040     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
2041     EXPECT_HR(hr, E_NOTIMPL);
2042     if (hr == S_OK && unk) IUnknown_Release(unk);
2043
2044     IDispatchEx_Release(dispex);
2045 }
2046
2047 static void test_dispex(void)
2048 {
2049     IXMLDOMSchemaCollection *cache;
2050     IUnknown *unk;
2051     HRESULT hr;
2052
2053     cache = create_cache(&IID_IXMLDOMSchemaCollection);
2054     if (!cache) return;
2055
2056     hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IUnknown, (void**)&unk);
2057     EXPECT_HR(hr, S_OK);
2058     test_obj_dispex(unk);
2059     IUnknown_Release(unk);
2060
2061     IXMLDOMSchemaCollection_Release(cache);
2062 }
2063
2064 START_TEST(schema)
2065 {
2066     HRESULT r;
2067
2068     r = CoInitialize( NULL );
2069     ok( r == S_OK, "failed to init com\n");
2070
2071     test_schema_refs();
2072     test_collection_refs();
2073     test_length();
2074     test_collection_content();
2075     test_XDR_schemas();
2076     test_XDR_datatypes();
2077     test_validate_on_load();
2078     test_dispex();
2079
2080     CoUninitialize();
2081 }