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     static const WCHAR emptyW[] = {0};
 497     IXMLDOMDocument2 *doc;
 498     IXMLDOMNode *node;
 499     IXMLDOMSchemaCollection *cache;
 500     VARIANT v;
 501     VARIANT_BOOL b;
 502     BSTR str;
 503     LONG len;
 504
 505     doc = create_document(&IID_IXMLDOMDocument2);
 506     if (!doc)
 507         return;
 508
 509     cache = create_cache(&IID_IXMLDOMSchemaCollection);
 510     if(!cache)
 511     {
 512         IXMLDOMDocument2_Release(doc);
 513         return;
 514     }
 515
 516     VariantInit(&v);
 517     str = SysAllocString(xdr_schema_xml);
 518     ole_check(IXMLDOMDocument2_loadXML(doc, str, &b));
 519     ok(b == VARIANT_TRUE, "b %04x\n", b);
 520     SysFreeString(str);
 521
 522     node = (void*)0xdeadbeef;
 523     ole_check(IXMLDOMSchemaCollection_get(cache, NULL, &node));
 524     ok(node == NULL, "%p\n", node);
 525
 526     /* NULL uri pointer, still adds a document */
 527     ole_check(IXMLDOMSchemaCollection_add(cache, NULL, _variantdoc_(doc)));
 528     len = -1;
 529     ole_check(IXMLDOMSchemaCollection_get_length(cache, &len));
 530     ok(len == 1, "got %d\n", len);
 531     /* read back - empty valid BSTR */
 532     str = NULL;
 533     ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache, 0, &str));
 534     ok(str && *str == 0, "got %p\n", str);
 535     SysFreeString(str);
 536
 537     node = NULL;
 538     ole_check(IXMLDOMSchemaCollection_get(cache, NULL, &node));
 539     ok(node != NULL, "%p\n", node);
 540     IXMLDOMNode_Release(node);
 541
 542     node = NULL;
 543     str = SysAllocString(emptyW);
 544     ole_check(IXMLDOMSchemaCollection_get(cache, str, &node));
 545     ok(node != NULL, "%p\n", node);
 546     IXMLDOMNode_Release(node);
 547     SysFreeString(str);
 548
 549     /* remove with NULL uri */
 550     ole_check(IXMLDOMSchemaCollection_remove(cache, NULL));
 551     len = -1;
 552     ole_check(IXMLDOMSchemaCollection_get_length(cache, &len));
 553     ok(len == 0, "got %d\n", len);
 554
 555     str = SysAllocString(xdr_schema_uri);
 556     ole_check(IXMLDOMSchemaCollection_add(cache, str, _variantdoc_(doc)));
 557
 558     /* IXMLDOMSchemaCollection_add doesn't add a ref on doc */
 559     check_refs(IXMLDOMDocument2, doc, 1);
 560
 561     SysFreeString(str);
 562
 563     V_VT(&v) = VT_INT;
 564     ole_expect(IXMLDOMDocument2_get_schemas(doc, &v), S_FALSE);
 565     ok(V_VT(&v) == VT_NULL, "vt %x\n", V_VT(&v));
 566
 567     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 568     V_VT(&v) = VT_DISPATCH;
 569     V_DISPATCH(&v) = (IDispatch*)cache;
 570
 571     /* check that putref_schemas takes a ref */
 572     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 573     check_refs(IXMLDOMSchemaCollection, cache, 3);
 574
 575     VariantClear(&v); /* refs now 2 */
 576
 577     V_VT(&v) = VT_INT;
 578     /* check that get_schemas adds a ref */
 579     ole_check(IXMLDOMDocument2_get_schemas(doc, &v));
 580     ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
 581     check_refs(IXMLDOMSchemaCollection, cache, 3);
 582
 583     /* get_schemas doesn't release a ref if passed VT_DISPATCH - ie it doesn't call VariantClear() */
 584     ole_check(IXMLDOMDocument2_get_schemas(doc, &v));
 585     ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
 586     check_refs(IXMLDOMSchemaCollection, cache, 4);
 587
 588     /* release the two refs returned by get_schemas */
 589     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 3);
 590     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 2);
 591
 592     /* check that taking another ref on the document doesn't change the schema's ref count */
 593     check_ref_expr(IXMLDOMDocument2_AddRef(doc), 2);
 594     check_refs(IXMLDOMSchemaCollection, cache, 2);
 595     check_ref_expr(IXMLDOMDocument2_Release(doc), 1);
 596
 597     /* call putref_schema with some odd variants */
 598     V_VT(&v) = VT_INT;
 599     ole_expect(IXMLDOMDocument2_putref_schemas(doc, v), E_FAIL);
 600     check_refs(IXMLDOMSchemaCollection, cache, 2);
 601
 602     /* calling with VT_EMPTY releases the schema */
 603     V_VT(&v) = VT_EMPTY;
 604     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 605     check_refs(IXMLDOMSchemaCollection, cache, 1);
 606
 607     /* try setting with VT_UNKNOWN */
 608     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 609     V_VT(&v) = VT_UNKNOWN;
 610     V_UNKNOWN(&v) = (IUnknown*)cache;
 611     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 612     check_refs(IXMLDOMSchemaCollection, cache, 3);
 613
 614     VariantClear(&v); /* refs now 2 */
 615
 616     /* calling with VT_NULL releases the schema */
 617     V_VT(&v) = VT_NULL;
 618     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 619     check_refs(IXMLDOMSchemaCollection, cache, 1);
 620
 621     /* refs now 1 */
 622     /* set again */
 623     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 624     V_VT(&v) = VT_UNKNOWN;
 625     V_UNKNOWN(&v) = (IUnknown*)cache;
 626     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 627     check_refs(IXMLDOMSchemaCollection, cache, 3);
 628
 629     VariantClear(&v); /* refs now 2 */
 630
 631     /* release the final ref on the doc which should release its ref on the schema */
 632     check_ref_expr(IXMLDOMDocument2_Release(doc), 0);
 633
 634     check_refs(IXMLDOMSchemaCollection, cache, 1);
 635     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 0);
 636 }
 637
 638 static void test_collection_refs(void)
 639 {
 640     IXMLDOMDocument2 *schema1, *schema2, *schema3;
 641     IXMLDOMSchemaCollection *cache1, *cache2, *cache3;
 642     VARIANT_BOOL b;
 643     LONG length;
 644
 645     schema1 = create_document(&IID_IXMLDOMDocument2);
 646     schema2 = create_document(&IID_IXMLDOMDocument2);
 647     schema3 = create_document(&IID_IXMLDOMDocument2);
 648
 649     cache1 = create_cache(&IID_IXMLDOMSchemaCollection);
 650     cache2 = create_cache(&IID_IXMLDOMSchemaCollection);
 651     cache3 = create_cache(&IID_IXMLDOMSchemaCollection);
 652
 653     if (!schema1 || !schema2 || !schema3 || !cache1 || !cache2 || !cache3)
 654     {
 655         if (schema1) IXMLDOMDocument2_Release(schema1);
 656         if (schema2) IXMLDOMDocument2_Release(schema2);
 657         if (schema3) IXMLDOMDocument2_Release(schema3);
 658
 659         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 660         if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 661         if (cache3) IXMLDOMSchemaCollection_Release(cache2);
 662
 663         return;
 664     }
 665
 666     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 667     ok(b == VARIANT_TRUE, "failed to load XML\n");
 668
 669     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 670     ok(b == VARIANT_TRUE, "failed to load XML\n");
 671
 672     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 673     ok(b == VARIANT_TRUE, "failed to load XML\n");
 674
 675     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 676     ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 677     ole_check(IXMLDOMSchemaCollection_add(cache3, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 678
 679     check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 680     check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 681     check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 682     schema1 = NULL;
 683     schema2 = NULL;
 684     schema3 = NULL;
 685
 686     /* releasing the original doc does not affect the schema cache */
 687     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 688     ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 689     ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 690
 691     /* we get a read-only domdoc interface, created just for us */
 692     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 693     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 694     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 695
 696     ole_expect(IXMLDOMSchemaCollection_addCollection(cache1, NULL), E_POINTER);
 697     ole_check(IXMLDOMSchemaCollection_addCollection(cache2, cache1));
 698     ole_check(IXMLDOMSchemaCollection_addCollection(cache3, cache2));
 699
 700     length = -1;
 701     ole_check(IXMLDOMSchemaCollection_get_length(cache1, &length));
 702     ok(length == 1, "expected length 1, got %i\n", length);
 703
 704     length = -1;
 705     ole_check(IXMLDOMSchemaCollection_get_length(cache2, &length));
 706     ok(length == 2, "expected length 2, got %i\n", length);
 707
 708     length = -1;
 709     ole_check(IXMLDOMSchemaCollection_get_length(cache3, &length));
 710     ok(length == 3, "expected length 3, got %i\n", length);
 711
 712
 713     /* merging collections does not affect the ref count */
 714     check_refs(IXMLDOMSchemaCollection, cache1, 1);
 715     check_refs(IXMLDOMSchemaCollection, cache2, 1);
 716     check_refs(IXMLDOMSchemaCollection, cache3, 1);
 717
 718     /* nor does it affect the domdoc instances */
 719     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 720     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 721     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 722
 723     if (schema1) check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 724     if (schema2) check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 725     if (schema3) check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 726     schema1 = NULL;
 727     schema2 = NULL;
 728     schema3 = NULL;
 729
 730     /* releasing the domdoc instances doesn't change the cache */
 731     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 732     ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 733     ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 734
 735     /* we can just get them again */
 736     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 737     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 738     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 739
 740     /* releasing the caches does not affect the domdoc instances */
 741     check_ref_expr(IXMLDOMSchemaCollection_Release(cache1), 0);
 742     check_ref_expr(IXMLDOMSchemaCollection_Release(cache2), 0);
 743     check_ref_expr(IXMLDOMSchemaCollection_Release(cache3), 0);
 744
 745     /* they're just for us */
 746     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 747     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 748     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 749
 750     if (schema1) check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 751     if (schema2) check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 752     if (schema3) check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 753
 754     free_bstrs();
 755 }
 756
 757 static void test_length(void)
 758 {
 759     IXMLDOMDocument2 *schema1, *schema2, *schema3;
 760     IXMLDOMSchemaCollection *cache;
 761     VARIANT_BOOL b;
 762     VARIANT v;
 763     LONG length;
 764
 765     schema1 = create_document(&IID_IXMLDOMDocument2);
 766     schema2 = create_document(&IID_IXMLDOMDocument2);
 767     schema3 = create_document(&IID_IXMLDOMDocument2);
 768
 769     cache = create_cache(&IID_IXMLDOMSchemaCollection);
 770
 771     if (!schema1 || !schema2 || !schema3 || !cache)
 772     {
 773         if (schema1) IXMLDOMDocument2_Release(schema1);
 774         if (schema2) IXMLDOMDocument2_Release(schema2);
 775         if (schema3) IXMLDOMDocument2_Release(schema3);
 776
 777         if (cache) IXMLDOMSchemaCollection_Release(cache);
 778
 779         return;
 780     }
 781
 782     VariantInit(&v);
 783
 784     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 785     ok(b == VARIANT_TRUE, "failed to load XML\n");
 786
 787     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 788     ok(b == VARIANT_TRUE, "failed to load XML\n");
 789
 790     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 791     ok(b == VARIANT_TRUE, "failed to load XML\n");
 792
 793     ole_expect(IXMLDOMSchemaCollection_get_length(cache, NULL), E_POINTER);
 794
 795     /* MSDN lies; removing a nonexistent entry produces no error */
 796     ole_check(IXMLDOMSchemaCollection_remove(cache, NULL));
 797     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema1_uri)));
 798
 799     length = -1;
 800     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 801     ok(length == 0, "expected length 0, got %i\n", length);
 802
 803     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 804
 805     length = -1;
 806     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 807     ok(length == 1, "expected length 1, got %i\n", length);
 808
 809     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 810
 811     length = -1;
 812     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 813     ok(length == 2, "expected length 2, got %i\n", length);
 814
 815     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 816
 817     length = -1;
 818     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 819     ok(length == 3, "expected length 3, got %i\n", length);
 820
 821     /* adding with VT_NULL is the same as removing */
 822     V_VT(&v) = VT_NULL;
 823     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), v));
 824
 825     length = -1;
 826     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 827     ok(length == 2, "expected length 2, got %i\n", length);
 828
 829     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema2_uri)));
 830
 831     length = -1;
 832     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 833     ok(length == 1, "expected length 1, got %i\n", length);
 834
 835     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema3_uri)));
 836
 837     length = -1;
 838     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 839     ok(length == 0, "expected length 0, got %i\n", length);
 840
 841     IXMLDOMDocument2_Release(schema1);
 842     IXMLDOMDocument2_Release(schema2);
 843     IXMLDOMDocument2_Release(schema3);
 844     IXMLDOMSchemaCollection_Release(cache);
 845
 846     free_bstrs();
 847 }
 848
 849 static void test_collection_content(void)
 850 {
 851     IXMLDOMDocument2 *schema1, *schema2, *schema3, *schema4, *schema5;
 852     IXMLDOMSchemaCollection *cache1, *cache2;
 853     VARIANT_BOOL b;
 854     BSTR bstr;
 855     BSTR content[5] = {NULL, NULL, NULL, NULL, NULL};
 856     LONG length;
 857     int i, j;
 858
 859     schema1 = create_document_version(30, &IID_IXMLDOMDocument2);
 860     schema2 = create_document_version(30, &IID_IXMLDOMDocument2);
 861     schema3 = create_document_version(30, &IID_IXMLDOMDocument2);
 862
 863     cache1 = create_cache_version(30, &IID_IXMLDOMSchemaCollection);
 864     cache2 = create_cache_version(40, &IID_IXMLDOMSchemaCollection);
 865
 866     if (!schema1 || !schema2 || !schema3 || !cache1)
 867     {
 868         if (schema1) IXMLDOMDocument2_Release(schema1);
 869         if (schema2) IXMLDOMDocument2_Release(schema2);
 870         if (schema3) IXMLDOMDocument2_Release(schema3);
 871
 872         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 873
 874         return;
 875     }
 876
 877     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 878     ok(b == VARIANT_TRUE, "failed to load XML\n");
 879
 880     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 881     ok(b == VARIANT_TRUE, "failed to load XML\n");
 882
 883     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 884     ok(b == VARIANT_TRUE, "failed to load XML\n");
 885
 886     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 887     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 888     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 889
 890     length = -1;
 891     ole_check(IXMLDOMSchemaCollection_get_length(cache1, &length));
 892     ok(length == 3, "expected length 3, got %i\n", length);
 893
 894     IXMLDOMDocument2_Release(schema1);
 895     IXMLDOMDocument2_Release(schema2);
 896     IXMLDOMDocument2_Release(schema3);
 897
 898     if (cache2)
 899     {
 900         schema1 = create_document_version(40, &IID_IXMLDOMDocument2);
 901         schema2 = create_document_version(40, &IID_IXMLDOMDocument2);
 902         schema3 = create_document_version(40, &IID_IXMLDOMDocument2);
 903         schema4 = create_document_version(40, &IID_IXMLDOMDocument2);
 904         schema5 = create_document_version(40, &IID_IXMLDOMDocument2);
 905         ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 906         ok(b == VARIANT_TRUE, "failed to load XML\n");
 907         ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 908         ok(b == VARIANT_TRUE, "failed to load XML\n");
 909         ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xsd_schema1_xml), &b));
 910         ok(b == VARIANT_TRUE, "failed to load XML\n");
 911         ole_check(IXMLDOMDocument2_loadXML(schema4, _bstr_(xsd_schema2_xml), &b));
 912         ok(b == VARIANT_TRUE, "failed to load XML\n");
 913         ole_check(IXMLDOMDocument2_loadXML(schema5, _bstr_(xsd_schema3_xml), &b));
 914         ok(b == VARIANT_TRUE, "failed to load XML\n");
 915
 916         /* combining XDR and XSD schemas in the same cache is fine */
 917         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 918         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 919         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema1_uri), _variantdoc_(schema3)));
 920         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema2_uri), _variantdoc_(schema4)));
 921         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema3_uri), _variantdoc_(schema5)));
 922
 923         length = -1;
 924         ole_check(IXMLDOMSchemaCollection_get_length(cache2, &length));
 925         ok(length == 5, "expected length 5, got %i\n", length);
 926
 927         IXMLDOMDocument2_Release(schema1);
 928         IXMLDOMDocument2_Release(schema2);
 929         IXMLDOMDocument2_Release(schema3);
 930         IXMLDOMDocument2_Release(schema4);
 931         IXMLDOMDocument2_Release(schema5);
 932     }
 933
 934     bstr = NULL;
 935     /* error if index is out of range */
 936     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, &bstr), E_FAIL);
 937     SysFreeString(bstr);
 938     /* error if return pointer is NULL */
 939     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 0, NULL), E_POINTER);
 940     /* pointer is checked first */
 941     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, NULL), E_POINTER);
 942
 943     schema1 = NULL;
 944     /* no error if ns uri does not exist */
 945     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xsd_schema1_uri), (IXMLDOMNode**)&schema1));
 946     ok(!schema1, "expected NULL\n");
 947     /* a NULL bstr corresponds to no-uri ns */
 948     ole_check(IXMLDOMSchemaCollection_get(cache1, NULL, (IXMLDOMNode**)&schema1));
 949     ok(!schema1, "expected NULL\n");
 950     /* error if return pointer is NULL */
 951     ole_expect(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), NULL), E_POINTER);
 952
 953     for (i = 0; i < 3; ++i)
 954     {
 955         bstr = NULL;
 956         ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache1, i, &bstr));
 957         ok(bstr != NULL && *bstr, "expected non-empty string\n");
 958         content[i] = bstr;
 959
 960         for (j = 0; j < i; ++j)
 961             ok(winetest_strcmpW(content[j], bstr), "got duplicate entry\n");
 962     }
 963
 964     for (i = 0; i < 3; ++i)
 965     {
 966         SysFreeString(content[i]);
 967         content[i] = NULL;
 968     }
 969
 970     if (cache2)
 971     {
 972         for (i = 0; i < 5; ++i)
 973         {
 974             bstr = NULL;
 975             ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache2, i, &bstr));
 976             ok(bstr != NULL && *bstr, "expected non-empty string\n");
 977
 978             for (j = 0; j < i; ++j)
 979                 ok(winetest_strcmpW(content[j], bstr), "got duplicate entry\n");
 980             content[i] = bstr;
 981         }
 982
 983         for (i = 0; i < 5; ++i)
 984         {
 985             SysFreeString(content[i]);
 986             content[i] = NULL;
 987         }
 988     }
 989
 990     IXMLDOMSchemaCollection_Release(cache1);
 991     if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 992
 993     free_bstrs();
 994 }
 995
 996 static void test_XDR_schemas(void)
 997 {
 998     IXMLDOMDocument2 *doc, *schema;
 999     IXMLDOMSchemaCollection* cache;
1000     IXMLDOMParseError* err;
1001     VARIANT_BOOL b;
1002     VARIANT v;
1003     BSTR bstr;
1004
1005     doc = create_document(&IID_IXMLDOMDocument2);
1006     schema = create_document(&IID_IXMLDOMDocument2);
1007     cache = create_cache(&IID_IXMLDOMSchemaCollection);
1008
1009     if (!doc || !schema || !cache)
1010     {
1011         if (doc)    IXMLDOMDocument2_Release(doc);
1012         if (schema) IXMLDOMDocument2_Release(schema);
1013         if (cache)  IXMLDOMSchemaCollection_Release(cache);
1014
1015         return;
1016     }
1017
1018     VariantInit(&v);
1019
1020     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML1), &b));
1021     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1022
1023     ole_check(IXMLDOMDocument2_loadXML(schema, _bstr_(szOpenSeqXDR), &b));
1024     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1025
1026     /* load the schema */
1027     V_VT(&v) = VT_DISPATCH;
1028     V_DISPATCH(&v) = NULL;
1029     ole_check(IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1030     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1031     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(""), v));
1032     VariantClear(&v);
1033
1034     /* associate the cache to the doc */
1035     V_VT(&v) = VT_DISPATCH;
1036     V_DISPATCH(&v) = NULL;
1037     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1038     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1039     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1040     VariantClear(&v);
1041
1042     /* validate the doc
1043      * only declared elements in the declared order
1044      * this is fine */
1045     err = NULL;
1046     bstr = NULL;
1047     ole_check(IXMLDOMDocument2_validate(doc, &err));
1048     ok(err != NULL, "domdoc_validate() should always set err\n");
1049     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
1050     ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
1051     SysFreeString(bstr);
1052     IXMLDOMParseError_Release(err);
1053
1054     /* load the next doc */
1055     IXMLDOMDocument2_Release(doc);
1056     doc = create_document(&IID_IXMLDOMDocument2);
1057     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML2), &b));
1058     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1059
1060     /* associate the cache to the doc */
1061     V_VT(&v) = VT_DISPATCH;
1062     V_DISPATCH(&v) = NULL;
1063     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1064     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1065     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1066     VariantClear(&v);
1067
1068     /* validate the doc
1069      * declared elements in the declared order, with an extra declared element at the end
1070      * this is fine */
1071     err = NULL;
1072     bstr = NULL;
1073     ole_check(IXMLDOMDocument2_validate(doc, &err));
1074     ok(err != NULL, "domdoc_validate() should always set err\n");
1075     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
1076     ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
1077     SysFreeString(bstr);
1078     IXMLDOMParseError_Release(err);
1079
1080     /* load the next doc */
1081     IXMLDOMDocument2_Release(doc);
1082     doc = create_document(&IID_IXMLDOMDocument2);
1083     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML3), &b));
1084     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1085
1086     /* associate the cache to the doc */
1087     V_VT(&v) = VT_DISPATCH;
1088     V_DISPATCH(&v) = NULL;
1089     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1090     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1091     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1092     VariantClear(&v);
1093
1094     /* validate the doc
1095      * fails, extra elements are only allowed at the end */
1096     err = NULL;
1097     bstr = NULL;
1098     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
1099     ok(err != NULL, "domdoc_validate() should always set err\n");
1100     todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
1101     SysFreeString(bstr);
1102     IXMLDOMParseError_Release(err);
1103
1104     /* load the next doc */
1105     IXMLDOMDocument2_Release(doc);
1106     doc = create_document(&IID_IXMLDOMDocument2);
1107     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML4), &b));
1108     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1109
1110     /* associate the cache to the doc */
1111     V_VT(&v) = VT_DISPATCH;
1112     V_DISPATCH(&v) = NULL;
1113     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1114     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1115     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1116     VariantClear(&v);
1117
1118     /* validate the doc
1119      * fails, undeclared elements are not allowed */
1120     err = NULL;
1121     bstr = NULL;
1122     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
1123     ok(err != NULL, "domdoc_validate() should always set err\n");
1124     todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
1125     SysFreeString(bstr);
1126     IXMLDOMParseError_Release(err);
1127
1128     IXMLDOMDocument2_Release(doc);
1129     IXMLDOMDocument2_Release(schema);
1130     IXMLDOMSchemaCollection_Release(cache);
1131
1132     free_bstrs();
1133 }
1134
1135 static void test_XDR_datatypes(void)
1136 {
1137     IXMLDOMDocument2 *doc, *schema;
1138     IXMLDOMSchemaCollection* cache;
1139     IXMLDOMNode* node;
1140     IXMLDOMParseError* err;
1141     VARIANT_BOOL b;
1142     VARIANT v, vtmp;
1143     LONG l;
1144     BSTR bstr;
1145
1146     VariantInit(&v);
1147
1148     doc = create_document(&IID_IXMLDOMDocument2);
1149     schema = create_document(&IID_IXMLDOMDocument2);
1150     cache = create_cache(&IID_IXMLDOMSchemaCollection);
1151
1152     if (!doc || !schema || !cache)
1153     {
1154         if (doc)    IXMLDOMDocument2_Release(doc);
1155         if (schema) IXMLDOMDocument2_Release(schema);
1156         if (cache)  IXMLDOMSchemaCollection_Release(cache);
1157
1158         return;
1159     }
1160
1161     ole_check(IXMLDOMDocument2_loadXML(doc, _bstr_(szDatatypeXML), &b));
1162     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1163
1164     ole_check(IXMLDOMDocument2_loadXML(schema, _bstr_(szDatatypeXDR), &b));
1165     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1166
1167     err = NULL;
1168     ole_expect(IXMLDOMDocument2_validate(doc, &err), S_FALSE);
1169     ok(err != NULL, "domdoc_validate() should always set err\n");
1170     ole_check(IXMLDOMParseError_get_errorCode(err, &l));
1171     ok(l == E_XML_NODTD, "got %08x\n", l);
1172     IXMLDOMParseError_Release(err);
1173
1174     /* check data types without the schema */
1175     node = NULL;
1176     memset(&vtmp, -1, sizeof(VARIANT));
1177     V_VT(&vtmp) = VT_NULL;
1178     V_BSTR(&vtmp) = NULL;
1179     memset(&v, -1, sizeof(VARIANT));
1180     V_VT(&v) = VT_EMPTY;
1181     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBase64']/Value/base64Data"), &node));
1182     ok(node != NULL, "expected node\n");
1183     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1184     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1185     /* when returning VT_NULL, the pointer is set to NULL */
1186     ok(memcmp(&v, &vtmp, sizeof(VARIANT)) == 0, "got %p\n", V_BSTR(&v));
1187     if (V_VT(&v) == VT_BSTR)
1188         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1189     VariantClear(&v);
1190     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1191     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1192     VariantClear(&v);
1193     IXMLDOMNode_Release(node);
1194
1195     node = NULL;
1196     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testHex']/Value/hexData"), &node));
1197     ok(node != NULL, "expected node\n");
1198     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1199     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1200     if (V_VT(&v) == VT_BSTR)
1201         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1202     VariantClear(&v);
1203     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1204     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1205     VariantClear(&v);
1206     IXMLDOMNode_Release(node);
1207
1208     node = NULL;
1209     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBool']/Value/boolData"), &node));
1210     ok(node != NULL, "expected node\n");
1211     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1212     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1213     if (V_VT(&v) == VT_BSTR)
1214         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1215     VariantClear(&v);
1216     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1217     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1218     VariantClear(&v);
1219     IXMLDOMNode_Release(node);
1220
1221     node = NULL;
1222     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testChar']/Value/charData"), &node));
1223     ok(node != NULL, "expected node\n");
1224     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1225     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1226     if (V_VT(&v) == VT_BSTR)
1227         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1228     VariantClear(&v);
1229     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1230     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1231     VariantClear(&v);
1232     IXMLDOMNode_Release(node);
1233
1234     node = NULL;
1235     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDate']/Value/dateData"), &node));
1236     ok(node != NULL, "expected node\n");
1237     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1238     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1239     if (V_VT(&v) == VT_BSTR)
1240         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1241     VariantClear(&v);
1242     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1243     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1244     VariantClear(&v);
1245     IXMLDOMNode_Release(node);
1246
1247     node = NULL;
1248     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTime']/Value/dateTimeData"), &node));
1249     ok(node != NULL, "expected node\n");
1250     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1251     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1252     if (V_VT(&v) == VT_BSTR)
1253         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1254     VariantClear(&v);
1255     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1256     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1257     VariantClear(&v);
1258     IXMLDOMNode_Release(node);
1259
1260     node = NULL;
1261     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTimeTz']/Value/dateTimeTzData"), &node));
1262     ok(node != NULL, "expected node\n");
1263     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1264     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1265     if (V_VT(&v) == VT_BSTR)
1266         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1267     VariantClear(&v);
1268     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1269     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1270     VariantClear(&v);
1271     IXMLDOMNode_Release(node);
1272
1273     node = NULL;
1274     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFixed']/Value/fixedData"), &node));
1275     ok(node != NULL, "expected node\n");
1276     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1277     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1278     if (V_VT(&v) == VT_BSTR)
1279         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1280     VariantClear(&v);
1281     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1282     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1283     VariantClear(&v);
1284     IXMLDOMNode_Release(node);
1285
1286     node = NULL;
1287     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFloat']/Value/floatData"), &node));
1288     ok(node != NULL, "expected node\n");
1289     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1290     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1291     if (V_VT(&v) == VT_BSTR)
1292         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1293     VariantClear(&v);
1294     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1295     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1296     VariantClear(&v);
1297     IXMLDOMNode_Release(node);
1298
1299     node = NULL;
1300     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI1']/Value/i1Data"), &node));
1301     ok(node != NULL, "expected node\n");
1302     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1303     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1304     if (V_VT(&v) == VT_BSTR)
1305         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1306     VariantClear(&v);
1307     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1308     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1309     VariantClear(&v);
1310     IXMLDOMNode_Release(node);
1311
1312     node = NULL;
1313     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI2']/Value/i2Data"), &node));
1314     ok(node != NULL, "expected node\n");
1315     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1316     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1317     if (V_VT(&v) == VT_BSTR)
1318         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1319     VariantClear(&v);
1320     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1321     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1322     VariantClear(&v);
1323     IXMLDOMNode_Release(node);
1324
1325     node = NULL;
1326     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI4']/Value/i4Data"), &node));
1327     ok(node != NULL, "expected node\n");
1328     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1329     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1330     if (V_VT(&v) == VT_BSTR)
1331         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1332     VariantClear(&v);
1333     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1334     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1335     VariantClear(&v);
1336     IXMLDOMNode_Release(node);
1337
1338     node = NULL;
1339     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI8']/Value/i8Data"), &node));
1340     ok(node != NULL, "expected node\n");
1341     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1342     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1343     if (V_VT(&v) == VT_BSTR)
1344         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1345     VariantClear(&v);
1346     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1347     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1348     VariantClear(&v);
1349     IXMLDOMNode_Release(node);
1350
1351     node = NULL;
1352     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testInt']/Value/intData"), &node));
1353     ok(node != NULL, "expected node\n");
1354     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1355     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1356     if (V_VT(&v) == VT_BSTR)
1357         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1358     VariantClear(&v);
1359     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1360     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1361     VariantClear(&v);
1362     IXMLDOMNode_Release(node);
1363
1364     node = NULL;
1365     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtoken']/Value/nmtokData"), &node));
1366     ok(node != NULL, "expected node\n");
1367     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1368     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1369     if (V_VT(&v) == VT_BSTR)
1370         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1371     VariantClear(&v);
1372     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1373     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1374     VariantClear(&v);
1375     IXMLDOMNode_Release(node);
1376
1377     node = NULL;
1378     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtokens']/Value/nmtoksData"), &node));
1379     ok(node != NULL, "expected node\n");
1380     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1381     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1382     if (V_VT(&v) == VT_BSTR)
1383         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1384     VariantClear(&v);
1385     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1386     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1387     VariantClear(&v);
1388     IXMLDOMNode_Release(node);
1389
1390     node = NULL;
1391     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNumber']/Value/numData"), &node));
1392     ok(node != NULL, "expected node\n");
1393     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1394     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1395     if (V_VT(&v) == VT_BSTR)
1396         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1397     VariantClear(&v);
1398     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1399     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1400     VariantClear(&v);
1401     IXMLDOMNode_Release(node);
1402
1403     node = NULL;
1404     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR4']/Value/r4Data"), &node));
1405     ok(node != NULL, "expected node\n");
1406     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1407     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1408     if (V_VT(&v) == VT_BSTR)
1409         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1410     VariantClear(&v);
1411     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1412     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1413     VariantClear(&v);
1414     IXMLDOMNode_Release(node);
1415
1416     node = NULL;
1417     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR8']/Value/r8Data"), &node));
1418     ok(node != NULL, "expected node\n");
1419     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1420     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1421     if (V_VT(&v) == VT_BSTR)
1422         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1423     VariantClear(&v);
1424     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1425     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1426     VariantClear(&v);
1427     IXMLDOMNode_Release(node);
1428
1429     node = NULL;
1430     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testString']/Value/stringData"), &node));
1431     ok(node != NULL, "expected node\n");
1432     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1433     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1434     if (V_VT(&v) == VT_BSTR)
1435         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1436     VariantClear(&v);
1437     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1438     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1439     VariantClear(&v);
1440     IXMLDOMNode_Release(node);
1441
1442     node = NULL;
1443     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTime']/Value/timeData"), &node));
1444     ok(node != NULL, "expected node\n");
1445     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1446     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1447     if (V_VT(&v) == VT_BSTR)
1448         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1449     VariantClear(&v);
1450     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1451     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1452     VariantClear(&v);
1453     IXMLDOMNode_Release(node);
1454
1455     node = NULL;
1456     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTimeTz']/Value/timeTzData"), &node));
1457     ok(node != NULL, "expected node\n");
1458     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1459     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1460     if (V_VT(&v) == VT_BSTR)
1461         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1462     VariantClear(&v);
1463     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1464     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1465     VariantClear(&v);
1466     IXMLDOMNode_Release(node);
1467
1468     node = NULL;
1469     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU1']/Value/u1Data"), &node));
1470     ok(node != NULL, "expected node\n");
1471     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1472     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1473     if (V_VT(&v) == VT_BSTR)
1474         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1475     VariantClear(&v);
1476     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1477     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1478     VariantClear(&v);
1479     IXMLDOMNode_Release(node);
1480
1481     node = NULL;
1482     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU2']/Value/u2Data"), &node));
1483     ok(node != NULL, "expected node\n");
1484     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1485     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1486     if (V_VT(&v) == VT_BSTR)
1487         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1488     VariantClear(&v);
1489     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1490     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1491     VariantClear(&v);
1492     IXMLDOMNode_Release(node);
1493
1494     node = NULL;
1495     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU4']/Value/u4Data"), &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     node = NULL;
1508     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU8']/Value/u8Data"), &node));
1509     ok(node != NULL, "expected node\n");
1510     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1511     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1512     if (V_VT(&v) == VT_BSTR)
1513         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1514     VariantClear(&v);
1515     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1516     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1517     VariantClear(&v);
1518     IXMLDOMNode_Release(node);
1519
1520     node = NULL;
1521     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testURI']/Value/uriData"), &node));
1522     ok(node != NULL, "expected node\n");
1523     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1524     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1525     if (V_VT(&v) == VT_BSTR)
1526         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1527     VariantClear(&v);
1528     IXMLDOMNode_Release(node);
1529
1530     node = NULL;
1531     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testUUID']/Value/uuidData"), &node));
1532     ok(node != NULL, "expected node\n");
1533     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1534     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1535     if (V_VT(&v) == VT_BSTR)
1536         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1537     VariantClear(&v);
1538     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1539     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1540     VariantClear(&v);
1541     IXMLDOMNode_Release(node);
1542
1543     /* now load the schema */
1544     V_VT(&v) = VT_DISPATCH;
1545     V_DISPATCH(&v) = NULL;
1546     ole_check(IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1547     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1548     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_("urn:x-schema:datatype-test-xdr"), v));
1549     VariantClear(&v);
1550
1551     /* associate the cache to the doc */
1552     V_VT(&v) = VT_DISPATCH;
1553     V_DISPATCH(&v) = NULL;
1554     ole_check(IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v)));
1555     ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
1556     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
1557     VariantClear(&v);
1558
1559     /* validate the doc */
1560     err = NULL;
1561     l = 0;
1562     bstr = NULL;
1563     ole_check(IXMLDOMDocument2_validate(doc, &err));
1564     ok(err != NULL, "domdoc_validate() should always set err\n");
1565     ole_expect(IXMLDOMParseError_get_errorCode(err, &l), S_FALSE);
1566     ole_expect(IXMLDOMParseError_get_reason(err, &bstr), S_FALSE);
1567     ok(l == 0, "got %08x : %s\n", l, wine_dbgstr_w(bstr));
1568     SysFreeString(bstr);
1569     IXMLDOMParseError_Release(err);
1570
1571     /* check the data types again */
1572     node = NULL;
1573     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBase64']/Value/base64Data"), &node));
1574     ok(node != NULL, "expected node\n");
1575     ole_check(IXMLDOMNode_get_dataType(node, &v));
1576     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1577     if (V_VT(&v) == VT_BSTR)
1578         ok(lstrcmpW(V_BSTR(&v), _bstr_("bin.base64")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1579     VariantClear(&v);
1580     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1581     ok(V_VT(&v) == (VT_ARRAY|VT_UI1), "got variant type %i\n", V_VT(&v));
1582     VariantClear(&v);
1583     IXMLDOMNode_Release(node);
1584
1585     node = NULL;
1586     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testHex']/Value/hexData"), &node));
1587     ok(node != NULL, "expected node\n");
1588     ole_check(IXMLDOMNode_get_dataType(node, &v));
1589     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1590     if (V_VT(&v) == VT_BSTR)
1591         ok(lstrcmpW(V_BSTR(&v), _bstr_("bin.hex")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1592     VariantClear(&v);
1593     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1594     ok(V_VT(&v) == (VT_ARRAY|VT_UI1), "got variant type %i\n", V_VT(&v));
1595     VariantClear(&v);
1596     IXMLDOMNode_Release(node);
1597
1598     node = NULL;
1599     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testBool']/Value/boolData"), &node));
1600     ok(node != NULL, "expected node\n");
1601     ole_check(IXMLDOMNode_get_dataType(node, &v));
1602     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1603     if (V_VT(&v) == VT_BSTR)
1604         ok(lstrcmpW(V_BSTR(&v), _bstr_("boolean")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1605     VariantClear(&v);
1606     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1607     ok(V_VT(&v) == VT_BOOL, "got variant type %i\n", V_VT(&v));
1608     if (V_VT(&v) == VT_BOOL)
1609         ok(V_BOOL(&v) == VARIANT_TRUE, "got %04x\n", V_BOOL(&v));
1610     VariantClear(&v);
1611     IXMLDOMNode_Release(node);
1612
1613     node = NULL;
1614     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testChar']/Value/charData"), &node));
1615     ok(node != NULL, "expected node\n");
1616     ole_check(IXMLDOMNode_get_dataType(node, &v));
1617     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1618     if (V_VT(&v) == VT_BSTR)
1619         ok(lstrcmpW(V_BSTR(&v), _bstr_("char")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1620     VariantClear(&v);
1621     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1622     todo_wine ok(V_VT(&v) == VT_I4, "got variant type %i\n", V_VT(&v));
1623     if (V_VT(&v) == VT_I4)
1624         ok(V_I4(&v) == 'u', "got %08x\n", V_I4(&v));
1625     VariantClear(&v);
1626     IXMLDOMNode_Release(node);
1627
1628     node = NULL;
1629     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDate']/Value/dateData"), &node));
1630     ok(node != NULL, "expected node\n");
1631     ole_check(IXMLDOMNode_get_dataType(node, &v));
1632     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1633     if (V_VT(&v) == VT_BSTR)
1634         ok(lstrcmpW(V_BSTR(&v), _bstr_("date")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1635     VariantClear(&v);
1636     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1637     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1638     VariantClear(&v);
1639     IXMLDOMNode_Release(node);
1640
1641     node = NULL;
1642     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTime']/Value/dateTimeData"), &node));
1643     ok(node != NULL, "expected node\n");
1644     ole_check(IXMLDOMNode_get_dataType(node, &v));
1645     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1646     if (V_VT(&v) == VT_BSTR)
1647         ok(lstrcmpW(V_BSTR(&v), _bstr_("dateTime")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1648     VariantClear(&v);
1649     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1650     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1651     VariantClear(&v);
1652     IXMLDOMNode_Release(node);
1653
1654     node = NULL;
1655     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testDateTimeTz']/Value/dateTimeTzData"), &node));
1656     ok(node != NULL, "expected node\n");
1657     ole_check(IXMLDOMNode_get_dataType(node, &v));
1658     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1659     if (V_VT(&v) == VT_BSTR)
1660         ok(lstrcmpW(V_BSTR(&v), _bstr_("dateTime.tz")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1661     VariantClear(&v);
1662     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1663     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1664     VariantClear(&v);
1665     IXMLDOMNode_Release(node);
1666
1667     node = NULL;
1668     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFixed']/Value/fixedData"), &node));
1669     ok(node != NULL, "expected node\n");
1670     ole_check(IXMLDOMNode_get_dataType(node, &v));
1671     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1672     if (V_VT(&v) == VT_BSTR)
1673         ok(lstrcmpW(V_BSTR(&v), _bstr_("fixed.14.4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1674     VariantClear(&v);
1675     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1676     ok(V_VT(&v) == VT_CY, "got variant type %i\n", V_VT(&v));
1677     VariantClear(&v);
1678     IXMLDOMNode_Release(node);
1679
1680     node = NULL;
1681     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testFloat']/Value/floatData"), &node));
1682     ok(node != NULL, "expected node\n");
1683     ole_check(IXMLDOMNode_get_dataType(node, &v));
1684     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1685     if (V_VT(&v) == VT_BSTR)
1686         ok(lstrcmpW(V_BSTR(&v), _bstr_("float")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1687     VariantClear(&v);
1688     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1689     ok(V_VT(&v) == VT_R8, "got variant type %i\n", V_VT(&v));
1690     if (V_VT(&v) == VT_R8)
1691         ok(V_R8(&v) == (double)3.14159, "got %f\n", V_R8(&v));
1692     VariantClear(&v);
1693     IXMLDOMNode_Release(node);
1694
1695     node = NULL;
1696     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI1']/Value/i1Data"), &node));
1697     ok(node != NULL, "expected node\n");
1698     ole_check(IXMLDOMNode_get_dataType(node, &v));
1699     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1700     if (V_VT(&v) == VT_BSTR)
1701         ok(lstrcmpW(V_BSTR(&v), _bstr_("i1")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1702     VariantClear(&v);
1703     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1704     ok(V_VT(&v) == VT_I1, "got variant type %i\n", V_VT(&v));
1705     if (V_VT(&v) == VT_I1)
1706         ok(V_I1(&v) == 42, "got %i\n", V_I1(&v));
1707     VariantClear(&v);
1708     IXMLDOMNode_Release(node);
1709
1710     node = NULL;
1711     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI2']/Value/i2Data"), &node));
1712     ok(node != NULL, "expected node\n");
1713     ole_check(IXMLDOMNode_get_dataType(node, &v));
1714     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1715     if (V_VT(&v) == VT_BSTR)
1716         ok(lstrcmpW(V_BSTR(&v), _bstr_("i2")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1717     VariantClear(&v);
1718     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1719     ok(V_VT(&v) == VT_I2, "got variant type %i\n", V_VT(&v));
1720     if (V_VT(&v) == VT_I2)
1721         ok(V_I2(&v) == 420, "got %i\n", V_I2(&v));
1722     VariantClear(&v);
1723     IXMLDOMNode_Release(node);
1724
1725     node = NULL;
1726     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI4']/Value/i4Data"), &node));
1727     ok(node != NULL, "expected node\n");
1728     ole_check(IXMLDOMNode_get_dataType(node, &v));
1729     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1730     if (V_VT(&v) == VT_BSTR)
1731         ok(lstrcmpW(V_BSTR(&v), _bstr_("i4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1732     VariantClear(&v);
1733     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1734     ok(V_VT(&v) == VT_I4, "got variant type %i\n", V_VT(&v));
1735     if (V_VT(&v) == VT_I4)
1736         ok(V_I4(&v) == -420000000, "got %i\n", V_I4(&v));
1737     VariantClear(&v);
1738     IXMLDOMNode_Release(node);
1739
1740     node = NULL;
1741     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testI8']/Value/i8Data"), &node));
1742     ok(node != NULL, "expected node\n");
1743     ole_check(IXMLDOMNode_get_dataType(node, &v));
1744     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1745     if (V_VT(&v) == VT_BSTR)
1746         ok(lstrcmpW(V_BSTR(&v), _bstr_("i8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1747     VariantClear(&v);
1748     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1749     /* TODO: which platforms return VT_I8? */
1750     todo_wine ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1751     if (V_VT(&v) == VT_I8)
1752         expect_int64(V_I8(&v), -4200000000, 10);
1753     VariantClear(&v);
1754     IXMLDOMNode_Release(node);
1755
1756     node = NULL;
1757     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testInt']/Value/intData"), &node));
1758     ok(node != NULL, "expected node\n");
1759     ole_check(IXMLDOMNode_get_dataType(node, &v));
1760     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1761     if (V_VT(&v) == VT_BSTR)
1762         ok(lstrcmpW(V_BSTR(&v), _bstr_("int")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1763     VariantClear(&v);
1764     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1765     ok(V_VT(&v) == VT_I4, "got variant type %i\n", V_VT(&v));
1766     if (V_VT(&v) == VT_I4)
1767         ok(V_I4(&v) == 42, "got %i\n", V_I4(&v));
1768     VariantClear(&v);
1769     IXMLDOMNode_Release(node);
1770
1771     /* nmtoken does not return a bstr for get_dataType() */
1772     node = NULL;
1773     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtoken']/Value/nmtokData"), &node));
1774     ok(node != NULL, "expected node\n");
1775     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1776     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1777     if (V_VT(&v) == VT_BSTR)
1778         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1779     VariantClear(&v);
1780     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1781     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1782     VariantClear(&v);
1783     IXMLDOMNode_Release(node);
1784
1785     /* nmtokens does not return a bstr for get_dataType() */
1786     node = NULL;
1787     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNmtokens']/Value/nmtoksData"), &node));
1788     ok(node != NULL, "expected node\n");
1789     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1790     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1791     if (V_VT(&v) == VT_BSTR)
1792         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1793     VariantClear(&v);
1794     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1795     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1796     VariantClear(&v);
1797     IXMLDOMNode_Release(node);
1798
1799     node = NULL;
1800     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testNumber']/Value/numData"), &node));
1801     ok(node != NULL, "expected node\n");
1802     ole_check(IXMLDOMNode_get_dataType(node, &v));
1803     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1804     if (V_VT(&v) == VT_BSTR)
1805         ok(lstrcmpW(V_BSTR(&v), _bstr_("number")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1806     VariantClear(&v);
1807     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1808     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1809     VariantClear(&v);
1810     IXMLDOMNode_Release(node);
1811
1812     node = NULL;
1813     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR4']/Value/r4Data"), &node));
1814     ok(node != NULL, "expected node\n");
1815     ole_check(IXMLDOMNode_get_dataType(node, &v));
1816     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1817     if (V_VT(&v) == VT_BSTR)
1818         ok(lstrcmpW(V_BSTR(&v), _bstr_("r4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1819     VariantClear(&v);
1820     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1821     ok(V_VT(&v) == VT_R4, "got variant type %i\n", V_VT(&v));
1822     if (V_VT(&v) == VT_R4)
1823         ok(V_R4(&v) == (float)3.14159265, "got %f\n", V_R4(&v));
1824     VariantClear(&v);
1825     IXMLDOMNode_Release(node);
1826
1827     node = NULL;
1828     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testR8']/Value/r8Data"), &node));
1829     ok(node != NULL, "expected node\n");
1830     ole_check(IXMLDOMNode_get_dataType(node, &v));
1831     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1832     if (V_VT(&v) == VT_BSTR)
1833         ok(lstrcmpW(V_BSTR(&v), _bstr_("r8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1834     VariantClear(&v);
1835     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1836     ok(V_VT(&v) == VT_R8, "got variant type %i\n", V_VT(&v));
1837     if (V_VT(&v) == VT_R8)
1838         todo_wine ok(V_R8(&v) == (double)3.14159265358979323846, "got %.20f\n", V_R8(&v));
1839     VariantClear(&v);
1840     IXMLDOMNode_Release(node);
1841
1842     /* dt:string is the default, does not return a bstr for get_dataType() */
1843     node = NULL;
1844     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testString']/Value/stringData"), &node));
1845     ok(node != NULL, "expected node\n");
1846     ole_expect(IXMLDOMNode_get_dataType(node, &v), S_FALSE);
1847     ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1848     if (V_VT(&v) == VT_BSTR)
1849         ok(0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1850     VariantClear(&v);
1851     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1852     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1853     VariantClear(&v);
1854     IXMLDOMNode_Release(node);
1855
1856     node = NULL;
1857     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTime']/Value/timeData"), &node));
1858     ok(node != NULL, "expected node\n");
1859     ole_check(IXMLDOMNode_get_dataType(node, &v));
1860     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1861     if (V_VT(&v) == VT_BSTR)
1862         ok(lstrcmpW(V_BSTR(&v), _bstr_("time")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1863     VariantClear(&v);
1864     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1865     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1866     VariantClear(&v);
1867     IXMLDOMNode_Release(node);
1868
1869     node = NULL;
1870     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testTimeTz']/Value/timeTzData"), &node));
1871     ok(node != NULL, "expected node\n");
1872     ole_check(IXMLDOMNode_get_dataType(node, &v));
1873     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1874     if (V_VT(&v) == VT_BSTR)
1875         ok(lstrcmpW(V_BSTR(&v), _bstr_("time.tz")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1876     VariantClear(&v);
1877     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1878     ok(V_VT(&v) == VT_DATE, "got variant type %i\n", V_VT(&v));
1879     VariantClear(&v);
1880     IXMLDOMNode_Release(node);
1881
1882     node = NULL;
1883     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU1']/Value/u1Data"), &node));
1884     ok(node != NULL, "expected node\n");
1885     ole_check(IXMLDOMNode_get_dataType(node, &v));
1886     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1887     if (V_VT(&v) == VT_BSTR)
1888         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui1")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1889     VariantClear(&v);
1890     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1891     ok(V_VT(&v) == VT_UI1, "got variant type %i\n", V_VT(&v));
1892     if (V_VT(&v) == VT_UI1)
1893         ok(V_UI1(&v) == 0xFF, "got %02x\n", V_UI1(&v));
1894     VariantClear(&v);
1895     IXMLDOMNode_Release(node);
1896
1897     node = NULL;
1898     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU2']/Value/u2Data"), &node));
1899     ok(node != NULL, "expected node\n");
1900     ole_check(IXMLDOMNode_get_dataType(node, &v));
1901     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1902     if (V_VT(&v) == VT_BSTR)
1903         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui2")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1904     VariantClear(&v);
1905     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1906     ok(V_VT(&v) == VT_UI2, "got variant type %i\n", V_VT(&v));
1907     if (V_VT(&v) == VT_UI2)
1908         ok(V_UI2(&v) == 0xFFFF, "got %04x\n", V_UI2(&v));
1909     VariantClear(&v);
1910     IXMLDOMNode_Release(node);
1911
1912     node = NULL;
1913     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU4']/Value/u4Data"), &node));
1914     ok(node != NULL, "expected node\n");
1915     ole_check(IXMLDOMNode_get_dataType(node, &v));
1916     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1917     if (V_VT(&v) == VT_BSTR)
1918         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui4")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1919     VariantClear(&v);
1920     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1921     ok(V_VT(&v) == VT_UI4, "got variant type %i\n", V_VT(&v));
1922     if (V_VT(&v) == VT_UI4)
1923         ok(V_UI4(&v) == 0xFFFFFFFF, "got %08x\n", V_UI4(&v));
1924     VariantClear(&v);
1925     IXMLDOMNode_Release(node);
1926
1927     node = NULL;
1928     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testU8']/Value/u8Data"), &node));
1929     ok(node != NULL, "expected node\n");
1930     ole_check(IXMLDOMNode_get_dataType(node, &v));
1931     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1932     if (V_VT(&v) == VT_BSTR)
1933         ok(lstrcmpW(V_BSTR(&v), _bstr_("ui8")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1934     VariantClear(&v);
1935     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1936     /* TODO: which platforms return VT_UI8? */
1937     todo_wine ok(V_VT(&v) == VT_NULL, "got variant type %i\n", V_VT(&v));
1938     if (V_VT(&v) == VT_UI8)
1939         expect_uint64(V_UI8(&v), 0xFFFFFFFFFFFFFFFF, 16);
1940     VariantClear(&v);
1941     IXMLDOMNode_Release(node);
1942
1943     node = NULL;
1944     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testURI']/Value/uriData"), &node));
1945     ok(node != NULL, "expected node\n");
1946     ole_check(IXMLDOMNode_get_dataType(node, &v));
1947     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1948     if (V_VT(&v) == VT_BSTR)
1949         ok(lstrcmpW(V_BSTR(&v), _bstr_("uri")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1950     VariantClear(&v);
1951     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1952     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1953     VariantClear(&v);
1954     IXMLDOMNode_Release(node);
1955
1956     node = NULL;
1957     ole_check(IXMLDOMDocument2_selectSingleNode(doc, _bstr_("//Property[Name!text()='testUUID']/Value/uuidData"), &node));
1958     ok(node != NULL, "expected node\n");
1959     ole_check(IXMLDOMNode_get_dataType(node, &v));
1960     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1961     if (V_VT(&v) == VT_BSTR)
1962         ok(lstrcmpW(V_BSTR(&v), _bstr_("uuid")) == 0, "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
1963     VariantClear(&v);
1964     ole_check(IXMLDOMNode_get_nodeTypedValue(node, &v));
1965     ok(V_VT(&v) == VT_BSTR, "got variant type %i\n", V_VT(&v));
1966     VariantClear(&v);
1967     IXMLDOMNode_Release(node);
1968
1969     ok(IXMLDOMDocument2_Release(schema) == 0, "schema not released\n");
1970     ok(IXMLDOMDocument2_Release(doc) == 0, "doc not released\n");
1971     ok(IXMLDOMSchemaCollection_Release(cache) == 0, "cache not released\n");
1972
1973     free_bstrs();
1974 }
1975
1976 START_TEST(schema)
1977 {
1978     HRESULT r;
1979
1980     r = CoInitialize( NULL );
1981     ok( r == S_OK, "failed to init com\n");
1982
1983     test_schema_refs();
1984     test_collection_refs();
1985     test_length();
1986     test_collection_content();
1987     test_XDR_schemas();
1988     test_XDR_datatypes();
1989
1990     CoUninitialize();
1991 }