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
 136 #define check_ref_expr(expr, n) { \
 137     LONG ref = expr; \
 138     ok(ref == n, "expected %i refs, got %i\n", n, ref); \
 139 }
 140
 141 #define check_refs(iface, obj, n) { \
 142     LONG ref = iface ## _AddRef(obj); \
 143     ok(ref == n+1, "expected %i refs, got %i\n", n+1, ref); \
 144     ref = iface ## _Release(obj); \
 145     ok(ref == n, "expected %i refs, got %i\n", n, ref); \
 146 }
 147
 148 #define ole_check(expr) { \
 149     HRESULT r = expr; \
 150     ok(r == S_OK, #expr " returned %x\n", r); \
 151 }
 152
 153 #define ole_expect(expr, expect) { \
 154     HRESULT r = expr; \
 155     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
 156 }
 157
 158 static BSTR alloced_bstrs[256];
 159 static int alloced_bstrs_count;
 160
 161 static BSTR alloc_str_from_narrow(const char *str)
 162 {
 163     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 164     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
 165     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 166     return ret;
 167 }
 168
 169 static BSTR _bstr_(const char *str)
 170 {
 171     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
 172     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
 173     return alloced_bstrs[alloced_bstrs_count++];
 174 }
 175
 176 static void free_bstrs(void)
 177 {
 178     int i;
 179     for (i = 0; i < alloced_bstrs_count; i++)
 180         SysFreeString(alloced_bstrs[i]);
 181     alloced_bstrs_count = 0;
 182 }
 183
 184 static VARIANT _variantdoc_(void* doc)
 185 {
 186     VARIANT v;
 187     V_VT(&v) = VT_DISPATCH;
 188     V_DISPATCH(&v) = (IDispatch*)doc;
 189     return v;
 190 }
 191
 192 static void* _create_object(const GUID *clsid, const char *name, const IID *iid, int line)
 193 {
 194     void *obj = NULL;
 195     HRESULT hr;
 196
 197     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
 198     if (hr != S_OK)
 199         win_skip_(__FILE__,line)("failed to create %s instance: 0x%08x\n", name, hr);
 200
 201     return obj;
 202 }
 203
 204 #define _create(cls) cls, #cls
 205
 206 #define create_document(iid) _create_object(&_create(CLSID_DOMDocument), iid, __LINE__)
 207
 208 #define create_document_version(v, iid) _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
 209
 210 #define create_cache(iid) _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
 211
 212 #define create_cache_version(v, iid) _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)
 213
 214 static void test_schema_refs(void)
 215 {
 216     IXMLDOMDocument2 *doc;
 217     IXMLDOMSchemaCollection *cache;
 218     VARIANT v;
 219     VARIANT_BOOL b;
 220     BSTR str;
 221
 222     doc = create_document(&IID_IXMLDOMDocument2);
 223     if (!doc)
 224         return;
 225
 226     cache = create_cache(&IID_IXMLDOMSchemaCollection);
 227     if(!cache)
 228     {
 229         IXMLDOMDocument2_Release(doc);
 230         return;
 231     }
 232
 233     VariantInit(&v);
 234     str = SysAllocString(xdr_schema_xml);
 235     ole_check(IXMLDOMDocument2_loadXML(doc, str, &b));
 236     ok(b == VARIANT_TRUE, "b %04x\n", b);
 237     SysFreeString(str);
 238
 239     str = SysAllocString(xdr_schema_uri);
 240     ole_check(IXMLDOMSchemaCollection_add(cache, str, _variantdoc_(doc)));
 241
 242     /* IXMLDOMSchemaCollection_add doesn't add a ref on doc */
 243     check_refs(IXMLDOMDocument2, doc, 1);
 244
 245     SysFreeString(str);
 246
 247     V_VT(&v) = VT_INT;
 248     ole_expect(IXMLDOMDocument2_get_schemas(doc, &v), S_FALSE);
 249     ok(V_VT(&v) == VT_NULL, "vt %x\n", V_VT(&v));
 250
 251     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 252     V_VT(&v) = VT_DISPATCH;
 253     V_DISPATCH(&v) = (IDispatch*)cache;
 254
 255     /* check that putref_schemas takes a ref */
 256     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 257     check_refs(IXMLDOMSchemaCollection, cache, 3);
 258
 259     VariantClear(&v); /* refs now 2 */
 260
 261     V_VT(&v) = VT_INT;
 262     /* check that get_schemas adds a ref */
 263     ole_check(IXMLDOMDocument2_get_schemas(doc, &v));
 264     ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
 265     check_refs(IXMLDOMSchemaCollection, cache, 3);
 266
 267     /* get_schemas doesn't release a ref if passed VT_DISPATCH - ie it doesn't call VariantClear() */
 268     ole_check(IXMLDOMDocument2_get_schemas(doc, &v));
 269     ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
 270     check_refs(IXMLDOMSchemaCollection, cache, 4);
 271
 272     /* release the two refs returned by get_schemas */
 273     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 3);
 274     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 2);
 275
 276     /* check that taking another ref on the document doesn't change the schema's ref count */
 277     check_ref_expr(IXMLDOMDocument2_AddRef(doc), 2);
 278     check_refs(IXMLDOMSchemaCollection, cache, 2);
 279     check_ref_expr(IXMLDOMDocument2_Release(doc), 1);
 280
 281     /* call putref_schema with some odd variants */
 282     V_VT(&v) = VT_INT;
 283     ole_expect(IXMLDOMDocument2_putref_schemas(doc, v), E_FAIL);
 284     check_refs(IXMLDOMSchemaCollection, cache, 2);
 285
 286     /* calling with VT_EMPTY releases the schema */
 287     V_VT(&v) = VT_EMPTY;
 288     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 289     check_refs(IXMLDOMSchemaCollection, cache, 1);
 290
 291     /* try setting with VT_UNKNOWN */
 292     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 293     V_VT(&v) = VT_UNKNOWN;
 294     V_UNKNOWN(&v) = (IUnknown*)cache;
 295     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 296     check_refs(IXMLDOMSchemaCollection, cache, 3);
 297
 298     VariantClear(&v); /* refs now 2 */
 299
 300     /* calling with VT_NULL releases the schema */
 301     V_VT(&v) = VT_NULL;
 302     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 303     check_refs(IXMLDOMSchemaCollection, cache, 1);
 304
 305     /* refs now 1 */
 306     /* set again */
 307     check_ref_expr(IXMLDOMSchemaCollection_AddRef(cache), 2);
 308     V_VT(&v) = VT_UNKNOWN;
 309     V_UNKNOWN(&v) = (IUnknown*)cache;
 310     ole_check(IXMLDOMDocument2_putref_schemas(doc, v));
 311     check_refs(IXMLDOMSchemaCollection, cache, 3);
 312
 313     VariantClear(&v); /* refs now 2 */
 314
 315     /* release the final ref on the doc which should release its ref on the schema */
 316     check_ref_expr(IXMLDOMDocument2_Release(doc), 0);
 317
 318     check_refs(IXMLDOMSchemaCollection, cache, 1);
 319     check_ref_expr(IXMLDOMSchemaCollection_Release(cache), 0);
 320 }
 321
 322 static void test_collection_refs(void)
 323 {
 324     IXMLDOMDocument2 *schema1, *schema2, *schema3;
 325     IXMLDOMSchemaCollection *cache1, *cache2, *cache3;
 326     VARIANT_BOOL b;
 327     LONG length;
 328
 329     schema1 = create_document(&IID_IXMLDOMDocument2);
 330     schema2 = create_document(&IID_IXMLDOMDocument2);
 331     schema3 = create_document(&IID_IXMLDOMDocument2);
 332
 333     cache1 = create_cache(&IID_IXMLDOMSchemaCollection);
 334     cache2 = create_cache(&IID_IXMLDOMSchemaCollection);
 335     cache3 = create_cache(&IID_IXMLDOMSchemaCollection);
 336
 337     if (!schema1 || !schema2 || !schema3 || !cache1 || !cache2 || !cache3)
 338     {
 339         if (schema1) IXMLDOMDocument2_Release(schema1);
 340         if (schema2) IXMLDOMDocument2_Release(schema2);
 341         if (schema3) IXMLDOMDocument2_Release(schema3);
 342
 343         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 344         if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 345         if (cache3) IXMLDOMSchemaCollection_Release(cache2);
 346
 347         return;
 348     }
 349
 350     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 351     ok(b == VARIANT_TRUE, "failed to load XML\n");
 352
 353     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 354     ok(b == VARIANT_TRUE, "failed to load XML\n");
 355
 356     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 357     ok(b == VARIANT_TRUE, "failed to load XML\n");
 358
 359     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 360     ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 361     ole_check(IXMLDOMSchemaCollection_add(cache3, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 362
 363     check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 364     check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 365     check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 366     schema1 = NULL;
 367     schema2 = NULL;
 368     schema3 = NULL;
 369
 370     /* releasing the original doc does not affect the schema cache */
 371     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 372     ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 373     ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 374
 375     /* we get a read-only domdoc interface, created just for us */
 376     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 377     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 378     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 379
 380     ole_expect(IXMLDOMSchemaCollection_addCollection(cache1, NULL), E_POINTER);
 381     ole_check(IXMLDOMSchemaCollection_addCollection(cache2, cache1));
 382     ole_check(IXMLDOMSchemaCollection_addCollection(cache3, cache2));
 383
 384     length = -1;
 385     ole_check(IXMLDOMSchemaCollection_get_length(cache1, &length));
 386     ok(length == 1, "expected length 1, got %i\n", length);
 387
 388     length = -1;
 389     ole_check(IXMLDOMSchemaCollection_get_length(cache2, &length));
 390     ok(length == 2, "expected length 2, got %i\n", length);
 391
 392     length = -1;
 393     ole_check(IXMLDOMSchemaCollection_get_length(cache3, &length));
 394     ok(length == 3, "expected length 3, got %i\n", length);
 395
 396
 397     /* merging collections does not affect the ref count */
 398     check_refs(IXMLDOMSchemaCollection, cache1, 1);
 399     check_refs(IXMLDOMSchemaCollection, cache2, 1);
 400     check_refs(IXMLDOMSchemaCollection, cache3, 1);
 401
 402     /* nor does it affect the domdoc instances */
 403     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 404     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 405     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 406
 407     if (schema1) check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 408     if (schema2) check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 409     if (schema3) check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 410     schema1 = NULL;
 411     schema2 = NULL;
 412     schema3 = NULL;
 413
 414     /* releasing the domdoc instances doesn't change the cache */
 415     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 416     ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 417     ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 418
 419     /* we can just get them again */
 420     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 421     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 422     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 423
 424     /* releasing the caches does not affect the domdoc instances */
 425     check_ref_expr(IXMLDOMSchemaCollection_Release(cache1), 0);
 426     check_ref_expr(IXMLDOMSchemaCollection_Release(cache2), 0);
 427     check_ref_expr(IXMLDOMSchemaCollection_Release(cache3), 0);
 428
 429     /* they're just for us */
 430     if (schema1) check_refs(IXMLDOMDocument2, schema1, 1);
 431     if (schema2) check_refs(IXMLDOMDocument2, schema2, 1);
 432     if (schema3) check_refs(IXMLDOMDocument2, schema3, 1);
 433
 434     if (schema1) check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 435     if (schema2) check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 436     if (schema3) check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 437
 438     free_bstrs();
 439 }
 440
 441 static void test_length(void)
 442 {
 443     IXMLDOMDocument2 *schema1, *schema2, *schema3;
 444     IXMLDOMSchemaCollection *cache;
 445     VARIANT_BOOL b;
 446     VARIANT v;
 447     LONG length;
 448
 449     schema1 = create_document(&IID_IXMLDOMDocument2);
 450     schema2 = create_document(&IID_IXMLDOMDocument2);
 451     schema3 = create_document(&IID_IXMLDOMDocument2);
 452
 453     cache = create_cache(&IID_IXMLDOMSchemaCollection);
 454
 455     if (!schema1 || !schema2 || !schema3 || !cache)
 456     {
 457         if (schema1) IXMLDOMDocument2_Release(schema1);
 458         if (schema2) IXMLDOMDocument2_Release(schema2);
 459         if (schema3) IXMLDOMDocument2_Release(schema3);
 460
 461         if (cache) IXMLDOMSchemaCollection_Release(cache);
 462
 463         return;
 464     }
 465
 466     VariantInit(&v);
 467
 468     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 469     ok(b == VARIANT_TRUE, "failed to load XML\n");
 470
 471     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 472     ok(b == VARIANT_TRUE, "failed to load XML\n");
 473
 474     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 475     ok(b == VARIANT_TRUE, "failed to load XML\n");
 476
 477     ole_expect(IXMLDOMSchemaCollection_get_length(cache, NULL), E_POINTER);
 478
 479     /* MSDN lies; removing a nonexistent entry produces no error */
 480     ole_check(IXMLDOMSchemaCollection_remove(cache, NULL));
 481     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema1_uri)));
 482
 483     length = -1;
 484     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 485     ok(length == 0, "expected length 0, got %i\n", length);
 486
 487     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 488
 489     length = -1;
 490     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 491     ok(length == 1, "expected length 1, got %i\n", length);
 492
 493     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 494
 495     length = -1;
 496     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 497     ok(length == 2, "expected length 2, got %i\n", length);
 498
 499     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 500
 501     length = -1;
 502     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 503     ok(length == 3, "expected length 3, got %i\n", length);
 504
 505     /* adding with VT_NULL is the same as removing */
 506     V_VT(&v) = VT_NULL;
 507     ole_check(IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), v));
 508
 509     length = -1;
 510     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 511     ok(length == 2, "expected length 2, got %i\n", length);
 512
 513     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema2_uri)));
 514
 515     length = -1;
 516     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 517     ok(length == 1, "expected length 1, got %i\n", length);
 518
 519     ole_check(IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema3_uri)));
 520
 521     length = -1;
 522     ole_check(IXMLDOMSchemaCollection_get_length(cache, &length));
 523     ok(length == 0, "expected length 0, got %i\n", length);
 524
 525     IXMLDOMDocument2_Release(schema1);
 526     IXMLDOMDocument2_Release(schema2);
 527     IXMLDOMDocument2_Release(schema3);
 528     IXMLDOMSchemaCollection_Release(cache);
 529
 530     free_bstrs();
 531 }
 532
 533 static void test_collection_content(void)
 534 {
 535     IXMLDOMDocument2 *schema1, *schema2, *schema3, *schema4, *schema5;
 536     IXMLDOMSchemaCollection *cache1, *cache2;
 537     VARIANT_BOOL b;
 538     BSTR bstr;
 539     BSTR content[5] = {NULL, NULL, NULL, NULL, NULL};
 540     LONG length;
 541     int i, j;
 542
 543     schema1 = create_document_version(30, &IID_IXMLDOMDocument2);
 544     schema2 = create_document_version(30, &IID_IXMLDOMDocument2);
 545     schema3 = create_document_version(30, &IID_IXMLDOMDocument2);
 546
 547     cache1 = create_cache_version(30, &IID_IXMLDOMSchemaCollection);
 548     cache2 = create_cache_version(40, &IID_IXMLDOMSchemaCollection);
 549
 550     if (!schema1 || !schema2 || !schema3 || !cache1)
 551     {
 552         if (schema1) IXMLDOMDocument2_Release(schema1);
 553         if (schema2) IXMLDOMDocument2_Release(schema2);
 554         if (schema3) IXMLDOMDocument2_Release(schema3);
 555
 556         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 557
 558         return;
 559     }
 560
 561     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 562     ok(b == VARIANT_TRUE, "failed to load XML\n");
 563
 564     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 565     ok(b == VARIANT_TRUE, "failed to load XML\n");
 566
 567     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 568     ok(b == VARIANT_TRUE, "failed to load XML\n");
 569
 570     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 571     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 572     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 573
 574     length = -1;
 575     ole_check(IXMLDOMSchemaCollection_get_length(cache1, &length));
 576     ok(length == 3, "expected length 3, got %i\n", length);
 577
 578     IXMLDOMDocument2_Release(schema1);
 579     IXMLDOMDocument2_Release(schema2);
 580     IXMLDOMDocument2_Release(schema3);
 581
 582     if (cache2)
 583     {
 584         schema1 = create_document_version(40, &IID_IXMLDOMDocument2);
 585         schema2 = create_document_version(40, &IID_IXMLDOMDocument2);
 586         schema3 = create_document_version(40, &IID_IXMLDOMDocument2);
 587         schema4 = create_document_version(40, &IID_IXMLDOMDocument2);
 588         schema5 = create_document_version(40, &IID_IXMLDOMDocument2);
 589         ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 590         ok(b == VARIANT_TRUE, "failed to load XML\n");
 591         ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 592         ok(b == VARIANT_TRUE, "failed to load XML\n");
 593         ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xsd_schema1_xml), &b));
 594         ok(b == VARIANT_TRUE, "failed to load XML\n");
 595         ole_check(IXMLDOMDocument2_loadXML(schema4, _bstr_(xsd_schema2_xml), &b));
 596         ok(b == VARIANT_TRUE, "failed to load XML\n");
 597         ole_check(IXMLDOMDocument2_loadXML(schema5, _bstr_(xsd_schema3_xml), &b));
 598         ok(b == VARIANT_TRUE, "failed to load XML\n");
 599
 600         /* combining XDR and XSD schemas in the same cache is fine */
 601         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 602         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 603         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema1_uri), _variantdoc_(schema3)));
 604         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema2_uri), _variantdoc_(schema4)));
 605         ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xsd_schema3_uri), _variantdoc_(schema5)));
 606
 607         length = -1;
 608         ole_check(IXMLDOMSchemaCollection_get_length(cache2, &length));
 609         ok(length == 5, "expected length 5, got %i\n", length);
 610
 611         IXMLDOMDocument2_Release(schema1);
 612         IXMLDOMDocument2_Release(schema2);
 613         IXMLDOMDocument2_Release(schema3);
 614         IXMLDOMDocument2_Release(schema4);
 615         IXMLDOMDocument2_Release(schema5);
 616     }
 617
 618     bstr = NULL;
 619     /* error if index is out of range */
 620     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, &bstr), E_FAIL);
 621     SysFreeString(bstr);
 622     /* error if return pointer is NULL */
 623     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 0, NULL), E_POINTER);
 624     /* pointer is checked first */
 625     ole_expect(IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, NULL), E_POINTER);
 626
 627     schema1 = NULL;
 628     /* no error if ns uri does not exist */
 629     ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xsd_schema1_uri), (IXMLDOMNode**)&schema1));
 630     ok(!schema1, "expected NULL\n");
 631     /* a NULL bstr corresponds to no-uri ns */
 632     ole_check(IXMLDOMSchemaCollection_get(cache1, NULL, (IXMLDOMNode**)&schema1));
 633     ok(!schema1, "expected NULL\n");
 634     /* error if return pointer is NULL */
 635     ole_expect(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), NULL), E_POINTER);
 636
 637     for (i = 0; i < 3; ++i)
 638     {
 639         bstr = NULL;
 640         ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache1, i, &bstr));
 641         ok(bstr != NULL && *bstr, "expected non-empty string\n");
 642         content[i] = bstr;
 643
 644         for (j = 0; j < i; ++j)
 645             ok(lstrcmpW(content[j], bstr), "got duplicate entry\n");
 646     }
 647
 648     for (i = 0; i < 3; ++i)
 649     {
 650         SysFreeString(content[i]);
 651         content[i] = NULL;
 652     }
 653
 654     if (cache2)
 655     {
 656         for (i = 0; i < 5; ++i)
 657         {
 658             bstr = NULL;
 659             ole_check(IXMLDOMSchemaCollection_get_namespaceURI(cache2, i, &bstr));
 660             ok(bstr != NULL && *bstr, "expected non-empty string\n");
 661
 662             for (j = 0; j < i; ++j)
 663                 ok(lstrcmpW(content[j], bstr), "got duplicate entry\n");
 664             content[i] = bstr;
 665         }
 666
 667         for (i = 0; i < 5; ++i)
 668         {
 669             SysFreeString(content[i]);
 670             content[i] = NULL;
 671         }
 672     }
 673
 674     IXMLDOMSchemaCollection_Release(cache1);
 675     if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 676
 677     free_bstrs();
 678 }
 679
 680 START_TEST(schema)
 681 {
 682     HRESULT r;
 683
 684     r = CoInitialize( NULL );
 685     ok( r == S_OK, "failed to init com\n");
 686
 687     test_schema_refs();
 688     test_collection_refs();
 689     test_length();
 690     test_collection_content();
 691
 692     CoUninitialize();
 693 }