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