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
 328     schema1 = create_document(&IID_IXMLDOMDocument2);
 329     schema2 = create_document(&IID_IXMLDOMDocument2);
 330     schema3 = create_document(&IID_IXMLDOMDocument2);
 331
 332     cache1 = create_cache(&IID_IXMLDOMSchemaCollection);
 333     cache2 = create_cache(&IID_IXMLDOMSchemaCollection);
 334     cache3 = create_cache(&IID_IXMLDOMSchemaCollection);
 335
 336     if (!schema1 || !schema2 || !schema3 || !cache1 || !cache2 || !cache3)
 337     {
 338         if (schema1) IXMLDOMDocument2_Release(schema1);
 339         if (schema2) IXMLDOMDocument2_Release(schema2);
 340         if (schema3) IXMLDOMDocument2_Release(schema3);
 341
 342         if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 343         if (cache2) IXMLDOMSchemaCollection_Release(cache2);
 344         if (cache3) IXMLDOMSchemaCollection_Release(cache2);
 345
 346         return;
 347     }
 348
 349     ole_check(IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b));
 350     ok(b == VARIANT_TRUE, "failed to load XML\n");
 351
 352     ole_check(IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b));
 353     ok(b == VARIANT_TRUE, "failed to load XML\n");
 354
 355     ole_check(IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b));
 356     ok(b == VARIANT_TRUE, "failed to load XML\n");
 357
 358     ole_check(IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1)));
 359     ole_check(IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2)));
 360     ole_check(IXMLDOMSchemaCollection_add(cache3, _bstr_(xdr_schema3_uri), _variantdoc_(schema3)));
 361
 362     check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 363     check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 364     check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 365     schema1 = NULL;
 366     schema2 = NULL;
 367     schema3 = NULL;
 368
 369     /* releasing the original doc does not affect the schema cache */
 370     todo_wine ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 371     todo_wine ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 372     todo_wine ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 373
 374     /* we get a read-only domdoc interface, created just for us */
 375     if (schema1) todo_wine check_refs(IXMLDOMDocument2, schema1, 1);
 376     if (schema2) todo_wine check_refs(IXMLDOMDocument2, schema2, 1);
 377     if (schema3) todo_wine check_refs(IXMLDOMDocument2, schema3, 1);
 378
 379     todo_wine ole_check(IXMLDOMSchemaCollection_addCollection(cache2, cache1));
 380     todo_wine ole_check(IXMLDOMSchemaCollection_addCollection(cache3, cache2));
 381
 382     /* merging collections does not affect the ref count */
 383     check_refs(IXMLDOMSchemaCollection, cache1, 1);
 384     check_refs(IXMLDOMSchemaCollection, cache2, 1);
 385     check_refs(IXMLDOMSchemaCollection, cache3, 1);
 386
 387     /* nor does it affect the domdoc instances */
 388     if (schema1) todo_wine check_refs(IXMLDOMDocument2, schema1, 1);
 389     if (schema2) todo_wine check_refs(IXMLDOMDocument2, schema2, 1);
 390     if (schema3) todo_wine check_refs(IXMLDOMDocument2, schema3, 1);
 391
 392     if (schema1) todo_wine check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 393     if (schema2) todo_wine check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 394     if (schema3) todo_wine check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 395     schema1 = NULL;
 396     schema2 = NULL;
 397     schema3 = NULL;
 398
 399     /* releasing the domdoc instances doesn't change the cache */
 400     todo_wine ole_check(IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1));
 401     todo_wine ole_check(IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2));
 402     todo_wine ole_check(IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3));
 403
 404     /* we can just get them again */
 405     if (schema1) todo_wine check_refs(IXMLDOMDocument2, schema1, 1);
 406     if (schema2) todo_wine check_refs(IXMLDOMDocument2, schema2, 1);
 407     if (schema3) todo_wine check_refs(IXMLDOMDocument2, schema3, 1);
 408
 409     /* releasing the caches does not affect the domdoc instances */
 410     check_ref_expr(IXMLDOMSchemaCollection_Release(cache1), 0);
 411     check_ref_expr(IXMLDOMSchemaCollection_Release(cache2), 0);
 412     check_ref_expr(IXMLDOMSchemaCollection_Release(cache3), 0);
 413
 414     /* they're just for us */
 415     if (schema1) todo_wine check_refs(IXMLDOMDocument2, schema1, 1);
 416     if (schema2) todo_wine check_refs(IXMLDOMDocument2, schema2, 1);
 417     if (schema3) todo_wine check_refs(IXMLDOMDocument2, schema3, 1);
 418
 419     if (schema1) todo_wine check_ref_expr(IXMLDOMDocument2_Release(schema1), 0);
 420     if (schema2) todo_wine check_ref_expr(IXMLDOMDocument2_Release(schema2), 0);
 421     if (schema3) todo_wine check_ref_expr(IXMLDOMDocument2_Release(schema3), 0);
 422
 423     free_bstrs();
 424 }
 425
 426 START_TEST(schema)
 427 {
 428     HRESULT r;
 429
 430     r = CoInitialize( NULL );
 431     ok( r == S_OK, "failed to init com\n");
 432
 433     test_schema_refs();
 434     test_collection_refs();
 435
 436     CoUninitialize();
 437 }