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